[OpenMP][NFCI] Move OpenMP clause information to `lib/Frontend/OpenMP`

[jdoerfert]

Summary

This is a cleanup and normalization patch that also enables reuse with
Flang later on. A follow up will clean up and move the directive ->
clauses mapping.

[fghanim]

Thanks for doing this. I looked at all of it, and the changes seem to be you just moved things to llvm/Frontend, and fixed namespaces/includes to work correctly with the new location. Is there here anything else I am missing?

[jdoerfert]

In D77112#1953471, @fghanim wrote:

Thanks for doing this. I looked at all of it, and the changes seem to be you just moved things to llvm/Frontend, and fixed namespaces/includes to work correctly with the new location. Is there here anything else I am missing?

Not really. This moves the macros and the two helper functions (string -> enum, enum -> string) into lib/Frontend and adjusts everything to work again. No functional change was intended and no tests output changed.

[fghanim]

Figured as much, just wanted to be sure. Anyways, this one also LGTM
I'll wait a couple of days in case any one has comments, if not I'll approve it

[jdoerfert]

NOTE: I mixed this one up with the follow up that was approved already (D77113) and committed it. If it turns out to be problematic we revert but I'll leave it for now as there was a positive review from @fghanim .

[jdoerfert]

Reverted in 1858f4b50dd35c28b377ba5dbc572fed43a5d38a as some uses need fixing, didn't build clang-tidy locally apparently.

[jdoerfert]

Update with clang-tidy and documentation adjustments

[fghanim]

OK, As I said a few days ago, I went over the patch, and I didn't see any functional changes. I am accepting this patch.

[jdoerfert]

Rebase

[thakis]

Broke clang-tools-extra again: http://lab.llvm.org:8011/builders/clang-ppc64be-linux/builds/46759/steps/build%20stage%201/logs/stdio

[jdoerfert]

In D77112#1962936, @thakis wrote:

Broke clang-tools-extra again: http://lab.llvm.org:8011/builders/clang-ppc64be-linux/builds/46759/steps/build%20stage%201/logs/stdio

Fixed in 8ea07f62a6f06bdb7da981425227995423867a4d, I might have grabbed the wrong commit locally, apologies.

clang/include/clang/AST/ASTFwd.h

 class Stmt;
 #define STMT(DERIVED, BASE) class DERIVED;
 #include "clang/AST/StmtNodes.inc"
 class Type;
 #define TYPE(DERIVED, BASE) class DERIVED##Type;
 #include "clang/AST/TypeNodes.inc"
 class CXXCtorInitializer;
 class OMPClause;
-#define OPENMP_CLAUSE(KIND, CLASSNAME) class CLASSNAME;
-#include "clang/Basic/OpenMPKinds.def"
+#define OMP_CLAUSE_CLASS(Enum, Str, Class) class Class;
+#include "llvm/Frontend/OpenMP/OMPKinds.def"
 
 
 } // end namespace clang
 
 #endif

clang/include/clang/AST/ASTTypeTraits.h

 #include "clang/AST/DeclNodes.inc"
     NKI_Stmt,
 #define STMT(DERIVED, BASE) NKI_##DERIVED,
 #include "clang/AST/StmtNodes.inc"
     NKI_Type,
 #define TYPE(DERIVED, BASE) NKI_##DERIVED##Type,
 #include "clang/AST/TypeNodes.inc"
     NKI_OMPClause,
-#define OPENMP_CLAUSE(TextualSpelling, Class) NKI_##Class,
-#include "clang/Basic/OpenMPKinds.def"
+#define OMP_CLAUSE_CLASS(Enum, Str, Class) NKI_##Class,
+#include "llvm/Frontend/OpenMP/OMPKinds.def"
     NKI_NumberOfKinds
   };
 
   /// Use getFromNodeKind<T>() to construct the kind.
   ASTNodeKind(NodeKindId KindId) : KindId(KindId) {}
 
   /// Returns \c true if \c Base is a base kind of (or same as) \c
   ///   Derived.

 KIND_TO_KIND_ID(Type)
 KIND_TO_KIND_ID(OMPClause)
 #define DECL(DERIVED, BASE) KIND_TO_KIND_ID(DERIVED##Decl)
 #include "clang/AST/DeclNodes.inc"
 #define STMT(DERIVED, BASE) KIND_TO_KIND_ID(DERIVED)
 #include "clang/AST/StmtNodes.inc"
 #define TYPE(DERIVED, BASE) KIND_TO_KIND_ID(DERIVED##Type)
 #include "clang/AST/TypeNodes.inc"
-#define OPENMP_CLAUSE(TextualSpelling, Class) KIND_TO_KIND_ID(Class)
-#include "clang/Basic/OpenMPKinds.def"
+#define OMP_CLAUSE_CLASS(Enum, Str, Class) KIND_TO_KIND_ID(Class)
+#include "llvm/Frontend/OpenMP/OMPKinds.def"
 #undef KIND_TO_KIND_ID
 
 inline raw_ostream &operator<<(raw_ostream &OS, ASTNodeKind K) {
   OS << K.asStringRef();
   return OS;
 }
 
 /// A dynamically typed AST node container.

clang/include/clang/AST/OpenMPClause.h

public:
   /// Build 'allocator' clause with the given allocator.
   ///
   /// \param A Allocator.
   /// \param StartLoc Starting location of the clause.
   /// \param LParenLoc Location of '('.
   /// \param EndLoc Ending location of the clause.
   OMPAllocatorClause(Expr *A, SourceLocation StartLoc, SourceLocation LParenLoc,
                      SourceLocation EndLoc)
-      : OMPClause(OMPC_allocator, StartLoc, EndLoc), LParenLoc(LParenLoc),
-        Allocator(A) {}
+      : OMPClause(llvm::omp::OMPC_allocator, StartLoc, EndLoc),
+        LParenLoc(LParenLoc), Allocator(A) {}
 
   /// Build an empty clause.
   OMPAllocatorClause()
-      : OMPClause(OMPC_allocator, SourceLocation(), SourceLocation()) {}
+      : OMPClause(llvm::omp::OMPC_allocator, SourceLocation(),
+                  SourceLocation()) {}
 
   /// Sets the location of '('.
   void setLParenLoc(SourceLocation Loc) { LParenLoc = Loc; }
 
   /// Returns the location of '('.
   SourceLocation getLParenLoc() const { return LParenLoc; }
 
   /// Returns allocator.
   Expr *getAllocator() const { return cast_or_null<Expr>(Allocator); }
 
   child_range children() { return child_range(&Allocator, &Allocator + 1); }
 
   const_child_range children() const {
     return const_child_range(&Allocator, &Allocator + 1);
   }
 
   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() == OMPC_allocator;
+    return T->getClauseKind() == llvm::omp::OMPC_allocator;
   }
 };
 
 /// This represents clause 'allocate' in the '#pragma omp ...' directives.
 ///
 /// \code
 /// #pragma omp parallel private(a) allocate(omp_default_mem_alloc :a)
 /// \endcode
class OMPAllocateClause final
   /// \param LParenLoc Location of '('.
   /// \param Allocator Allocator expression.
   /// \param ColonLoc Location of ':' delimiter.
   /// \param EndLoc Ending location of the clause.
   /// \param N Number of the variables in the clause.
   OMPAllocateClause(SourceLocation StartLoc, SourceLocation LParenLoc,
                     Expr *Allocator, SourceLocation ColonLoc,
                     SourceLocation EndLoc, unsigned N)
-      : OMPVarListClause<OMPAllocateClause>(OMPC_allocate, StartLoc, LParenLoc,
-                                            EndLoc, N),
+      : OMPVarListClause<OMPAllocateClause>(llvm::omp::OMPC_allocate, StartLoc,
+                                            LParenLoc, EndLoc, N),
         Allocator(Allocator), ColonLoc(ColonLoc) {}
 
   /// Build an empty clause.
   ///
   /// \param N Number of variables.
   explicit OMPAllocateClause(unsigned N)
-      : OMPVarListClause<OMPAllocateClause>(OMPC_allocate, SourceLocation(),
+      : OMPVarListClause<OMPAllocateClause>(llvm::omp::OMPC_allocate,
                                             SourceLocation(), SourceLocation(),
-                                            N) {}
+                                            SourceLocation(), N) {}
 
   /// Sets location of ':' symbol in clause.
   void setColonLoc(SourceLocation CL) { ColonLoc = CL; }
 
   void setAllocator(Expr *A) { Allocator = A; }
 
 public:
   /// Creates clause with a list of variables \a VL.
public:
   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() == OMPC_allocate;
+    return T->getClauseKind() == llvm::omp::OMPC_allocate;
   }
 };
 
 /// This represents 'if' clause in the '#pragma omp ...' directive.
 ///
 /// \code
 /// #pragma omp parallel if(parallel:a > 5)
 /// \endcode
public:
   /// \param LParenLoc Location of '('.
   /// \param NameModifierLoc Location of directive name modifier.
   /// \param ColonLoc [OpenMP 4.1] Location of ':'.
   /// \param EndLoc Ending location of the clause.
   OMPIfClause(OpenMPDirectiveKind NameModifier, Expr *Cond, Stmt *HelperCond,
               OpenMPDirectiveKind CaptureRegion, SourceLocation StartLoc,
               SourceLocation LParenLoc, SourceLocation NameModifierLoc,
               SourceLocation ColonLoc, SourceLocation EndLoc)
-      : OMPClause(OMPC_if, StartLoc, EndLoc), OMPClauseWithPreInit(this),
-        LParenLoc(LParenLoc), Condition(Cond), ColonLoc(ColonLoc),
-        NameModifier(NameModifier), NameModifierLoc(NameModifierLoc) {
+      : OMPClause(llvm::omp::OMPC_if, StartLoc, EndLoc),
+        OMPClauseWithPreInit(this), LParenLoc(LParenLoc), Condition(Cond),
+        ColonLoc(ColonLoc), NameModifier(NameModifier),
+        NameModifierLoc(NameModifierLoc) {
     setPreInitStmt(HelperCond, CaptureRegion);
   }
 
   /// Build an empty clause.
   OMPIfClause()
-      : OMPClause(OMPC_if, SourceLocation(), SourceLocation()),
+      : OMPClause(llvm::omp::OMPC_if, SourceLocation(), SourceLocation()),
         OMPClauseWithPreInit(this) {}
 
   /// Sets the location of '('.
   void setLParenLoc(SourceLocation Loc) { LParenLoc = Loc; }
 
   /// Returns the location of '('.
   SourceLocation getLParenLoc() const { return LParenLoc; }
 
public:
 
   child_range used_children();
   const_child_range used_children() const {
     auto Children = const_cast<OMPIfClause *>(this)->used_children();
     return const_child_range(Children.begin(), Children.end());
   }
 
   static bool classof(const OMPClause *T) {
-    return T->getClauseKind() == OMPC_if;
+    return T->getClauseKind() == llvm::omp::OMPC_if;
   }
 };
 
 /// This represents 'final' clause in the '#pragma omp ...' directive.
 ///
 /// \code
 /// #pragma omp task final(a > 5)
 /// \endcode
public:
   /// \param CaptureRegion Innermost OpenMP region where expressions in this
   /// clause must be captured.
   /// \param StartLoc Starting location of the clause.
   /// \param LParenLoc Location of '('.
   /// \param EndLoc Ending location of the clause.
   OMPFinalClause(Expr *Cond, Stmt *HelperCond,
                  OpenMPDirectiveKind CaptureRegion, SourceLocation StartLoc,
                  SourceLocation LParenLoc, SourceLocation EndLoc)
-      : OMPClause(OMPC_final, StartLoc, EndLoc), OMPClauseWithPreInit(this),
-        LParenLoc(LParenLoc), Condition(Cond) {
+      : OMPClause(llvm::omp::OMPC_final, StartLoc, EndLoc),
+        OMPClauseWithPreInit(this), LParenLoc(LParenLoc), Condition(Cond) {
     setPreInitStmt(HelperCond, CaptureRegion);
   }
 
   /// Build an empty clause.
   OMPFinalClause()
-      : OMPClause(OMPC_final, SourceLocation(), SourceLocation()),
+      : OMPClause(llvm::omp::OMPC_final, SourceLocation(), SourceLocation()),
         OMPClauseWithPreInit(this) {}
 
   /// Sets the location of '('.
   void setLParenLoc(SourceLocation Loc) { LParenLoc = Loc; }
 
   /// Returns the location of '('.
   SourceLocation getLParenLoc() const { return LParenLoc; }
 
   /// Returns condition.
   Expr *getCondition() const { return cast_or_null<Expr>(Condition); }
 
   child_range children() { return child_range(&Condition, &Condition + 1); }
 
   const_child_range children() const {
     return const_child_range(&Condition, &Condition + 1);
   }
 
   child_range used_children();
   const_child_range used_children() const {
     auto Children = const_cast<OMPFinalClause *>(this)->used_children();
     return const_child_range(Children.begin(), Children.end());
   }
 
   static bool classof(const OMPClause *T) {
-    return T->getClauseKind() == OMPC_final;
+    return T->getClauseKind() == llvm::omp::OMPC_final;
   }
 };
 
 /// This represents 'num_threads' clause in the '#pragma omp ...'
 /// directive.
 ///
 /// \code
 /// #pragma omp parallel num_threads(6)
public:
   /// clause must be captured.
   /// \param StartLoc Starting location of the clause.
   /// \param LParenLoc Location of '('.
   /// \param EndLoc Ending location of the clause.
   OMPNumThreadsClause(Expr *NumThreads, Stmt *HelperNumThreads,
                       OpenMPDirectiveKind CaptureRegion,
                       SourceLocation StartLoc, SourceLocation LParenLoc,
                       SourceLocation EndLoc)
-      : OMPClause(OMPC_num_threads, StartLoc, EndLoc),
+      : OMPClause(llvm::omp::OMPC_num_threads, StartLoc, EndLoc),
         OMPClauseWithPreInit(this), LParenLoc(LParenLoc),
         NumThreads(NumThreads) {
     setPreInitStmt(HelperNumThreads, CaptureRegion);
   }
 
   /// Build an empty clause.
   OMPNumThreadsClause()
-      : OMPClause(OMPC_num_threads, SourceLocation(), SourceLocation()),
+      : OMPClause(llvm::omp::OMPC_num_threads, SourceLocation(),
+                  SourceLocation()),
         OMPClauseWithPreInit(this) {}
 
   /// Sets the location of '('.
   void setLParenLoc(SourceLocation Loc) { LParenLoc = Loc; }
 
   /// Returns the location of '('.
   SourceLocation getLParenLoc() const { return LParenLoc; }
 
public:
   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() == OMPC_num_threads;
+    return T->getClauseKind() == llvm::omp::OMPC_num_threads;
   }
 };
 
 /// This represents 'safelen' clause in the '#pragma omp ...'
 /// directive.
 ///
 /// \code
 /// #pragma omp simd safelen(4)

 public:
   /// Build 'safelen' clause.
   ///
   /// \param Len Expression associated with this clause.
   /// \param StartLoc Starting location of the clause.
   /// \param EndLoc Ending location of the clause.
   OMPSafelenClause(Expr *Len, SourceLocation StartLoc, SourceLocation LParenLoc,
                    SourceLocation EndLoc)
-      : OMPClause(OMPC_safelen, StartLoc, EndLoc), LParenLoc(LParenLoc),
-        Safelen(Len) {}
+      : OMPClause(llvm::omp::OMPC_safelen, StartLoc, EndLoc),
+        LParenLoc(LParenLoc), Safelen(Len) {}
 
   /// Build an empty clause.
   explicit OMPSafelenClause()
-      : OMPClause(OMPC_safelen, SourceLocation(), SourceLocation()) {}
+      : OMPClause(llvm::omp::OMPC_safelen, SourceLocation(), SourceLocation()) {
+  }
 
   /// Sets the location of '('.
   void setLParenLoc(SourceLocation Loc) { LParenLoc = Loc; }
 
   /// Returns the location of '('.
   SourceLocation getLParenLoc() const { return LParenLoc; }
 
   /// Return safe iteration space distance.
   Expr *getSafelen() const { return cast_or_null<Expr>(Safelen); }
 
   child_range children() { return child_range(&Safelen, &Safelen + 1); }
 
   const_child_range children() const {
     return const_child_range(&Safelen, &Safelen + 1);
   }
 
   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() == OMPC_safelen;
+    return T->getClauseKind() == llvm::omp::OMPC_safelen;
   }
 };
 
 /// This represents 'simdlen' clause in the '#pragma omp ...'
 /// directive.
 ///
 /// \code
 /// #pragma omp simd simdlen(4)

 public:
   /// Build 'simdlen' clause.
   ///
   /// \param Len Expression associated with this clause.
   /// \param StartLoc Starting location of the clause.
   /// \param EndLoc Ending location of the clause.
   OMPSimdlenClause(Expr *Len, SourceLocation StartLoc, SourceLocation LParenLoc,
                    SourceLocation EndLoc)
-      : OMPClause(OMPC_simdlen, StartLoc, EndLoc), LParenLoc(LParenLoc),
-        Simdlen(Len) {}
+      : OMPClause(llvm::omp::OMPC_simdlen, StartLoc, EndLoc),
+        LParenLoc(LParenLoc), Simdlen(Len) {}
 
   /// Build an empty clause.
   explicit OMPSimdlenClause()
-      : OMPClause(OMPC_simdlen, SourceLocation(), SourceLocation()) {}
+      : OMPClause(llvm::omp::OMPC_simdlen, SourceLocation(), SourceLocation()) {
+  }
 
   /// Sets the location of '('.
   void setLParenLoc(SourceLocation Loc) { LParenLoc = Loc; }
 
   /// Returns the location of '('.
   SourceLocation getLParenLoc() const { return LParenLoc; }
 
   /// Return safe iteration space distance.
   Expr *getSimdlen() const { return cast_or_null<Expr>(Simdlen); }
 
   child_range children() { return child_range(&Simdlen, &Simdlen + 1); }
 
   const_child_range children() const {
     return const_child_range(&Simdlen, &Simdlen + 1);
   }
 
   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() == OMPC_simdlen;
+    return T->getClauseKind() == llvm::omp::OMPC_simdlen;
   }
 };
 
 /// This represents 'collapse' clause in the '#pragma omp ...'
 /// directive.
 ///
 /// \code
 /// #pragma omp simd collapse(3)
public:
   /// Build 'collapse' clause.
   ///
   /// \param Num Expression associated with this clause.
   /// \param StartLoc Starting location of the clause.
   /// \param LParenLoc Location of '('.
   /// \param EndLoc Ending location of the clause.
   OMPCollapseClause(Expr *Num, SourceLocation StartLoc,
                     SourceLocation LParenLoc, SourceLocation EndLoc)
-      : OMPClause(OMPC_collapse, StartLoc, EndLoc), LParenLoc(LParenLoc),
-        NumForLoops(Num) {}
+      : OMPClause(llvm::omp::OMPC_collapse, StartLoc, EndLoc),
+        LParenLoc(LParenLoc), NumForLoops(Num) {}
 
   /// Build an empty clause.
   explicit OMPCollapseClause()
-      : OMPClause(OMPC_collapse, SourceLocation(), SourceLocation()) {}
+      : OMPClause(llvm::omp::OMPC_collapse, SourceLocation(),
+                  SourceLocation()) {}
 
   /// Sets the location of '('.
   void setLParenLoc(SourceLocation Loc) { LParenLoc = Loc; }
 
   /// Returns the location of '('.
   SourceLocation getLParenLoc() const { return LParenLoc; }
 
   /// Return the number of associated for-loops.
   Expr *getNumForLoops() const { return cast_or_null<Expr>(NumForLoops); }
 
   child_range children() { return child_range(&NumForLoops, &NumForLoops + 1); }
 
   const_child_range children() const {
     return const_child_range(&NumForLoops, &NumForLoops + 1);
   }
 
   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() == OMPC_collapse;
+    return T->getClauseKind() == llvm::omp::OMPC_collapse;
   }
 };
 
 /// This represents 'default' clause in the '#pragma omp ...' directive.
 ///
 /// \code
 /// #pragma omp parallel default(shared)
 /// \endcode
public:
   /// \param A Argument of the clause ('none' or 'shared').
   /// \param ALoc Starting location of the argument.
   /// \param StartLoc Starting location of the clause.
   /// \param LParenLoc Location of '('.
   /// \param EndLoc Ending location of the clause.
   OMPDefaultClause(llvm::omp::DefaultKind A, SourceLocation ALoc,
                    SourceLocation StartLoc, SourceLocation LParenLoc,
                    SourceLocation EndLoc)
-      : OMPClause(OMPC_default, StartLoc, EndLoc), LParenLoc(LParenLoc),
-        Kind(A), KindKwLoc(ALoc) {}
+      : OMPClause(llvm::omp::OMPC_default, StartLoc, EndLoc),
+        LParenLoc(LParenLoc), Kind(A), KindKwLoc(ALoc) {}
 
   /// Build an empty clause.
   OMPDefaultClause()
-      : OMPClause(OMPC_default, SourceLocation(), SourceLocation()) {}
+      : OMPClause(llvm::omp::OMPC_default, SourceLocation(), SourceLocation()) {
+  }
 
   /// Sets the location of '('.
   void setLParenLoc(SourceLocation Loc) { LParenLoc = Loc; }
 
   /// Returns the location of '('.
   SourceLocation getLParenLoc() const { return LParenLoc; }
 
   /// Returns kind of the clause.
public:
   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() == OMPC_default;
+    return T->getClauseKind() == llvm::omp::OMPC_default;
   }
 };
 
 /// This represents 'proc_bind' clause in the '#pragma omp ...'
 /// directive.
 ///
 /// \code
 /// #pragma omp parallel proc_bind(master)
public:
   /// \param A Argument of the clause ('master', 'close' or 'spread').
   /// \param ALoc Starting location of the argument.
   /// \param StartLoc Starting location of the clause.
   /// \param LParenLoc Location of '('.
   /// \param EndLoc Ending location of the clause.
   OMPProcBindClause(llvm::omp::ProcBindKind A, SourceLocation ALoc,
                     SourceLocation StartLoc, SourceLocation LParenLoc,
                     SourceLocation EndLoc)
-      : OMPClause(OMPC_proc_bind, StartLoc, EndLoc), LParenLoc(LParenLoc),
-        Kind(A), KindKwLoc(ALoc) {}
+      : OMPClause(llvm::omp::OMPC_proc_bind, StartLoc, EndLoc),
+        LParenLoc(LParenLoc), Kind(A), KindKwLoc(ALoc) {}
 
   /// Build an empty clause.
   OMPProcBindClause()
-      : OMPClause(OMPC_proc_bind, SourceLocation(), SourceLocation()) {}
+      : OMPClause(llvm::omp::OMPC_proc_bind, SourceLocation(),
+                  SourceLocation()) {}
 
   /// Sets the location of '('.
   void setLParenLoc(SourceLocation Loc) { LParenLoc = Loc; }
 
   /// Returns the location of '('.
   SourceLocation getLParenLoc() const { return LParenLoc; }
 
   /// Returns kind of the clause.
public:
   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() == OMPC_proc_bind;
+    return T->getClauseKind() == llvm::omp::OMPC_proc_bind;
   }
 };
 
 /// This represents 'unified_address' clause in the '#pragma omp requires'
 /// directive.
 ///
 /// \code
 /// #pragma omp requires unified_address
 /// \endcode
 /// In this example directive '#pragma omp requires' has 'unified_address'
 /// clause.
 class OMPUnifiedAddressClause final : public OMPClause {
 public:
   friend class OMPClauseReader;
   /// Build 'unified_address' clause.
   ///
   /// \param StartLoc Starting location of the clause.
   /// \param EndLoc Ending location of the clause.
   OMPUnifiedAddressClause(SourceLocation StartLoc, SourceLocation EndLoc)
-      : OMPClause(OMPC_unified_address, StartLoc, EndLoc) {}
+      : OMPClause(llvm::omp::OMPC_unified_address, StartLoc, EndLoc) {}
 
   /// Build an empty clause.
   OMPUnifiedAddressClause()
-      : OMPClause(OMPC_unified_address, SourceLocation(), SourceLocation()) {}
+      : OMPClause(llvm::omp::OMPC_unified_address, 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() == OMPC_unified_address;
+    return T->getClauseKind() == llvm::omp::OMPC_unified_address;
   }
 };
 
 /// This represents 'unified_shared_memory' clause in the '#pragma omp requires'
 /// directive.
 ///
 /// \code
 /// #pragma omp requires unified_shared_memory
 /// \endcode
 /// In this example directive '#pragma omp requires' has 'unified_shared_memory'
 /// clause.
 class OMPUnifiedSharedMemoryClause final : public OMPClause {
 public:
   friend class OMPClauseReader;
   /// Build 'unified_shared_memory' clause.
   ///
   /// \param StartLoc Starting location of the clause.
   /// \param EndLoc Ending location of the clause.
   OMPUnifiedSharedMemoryClause(SourceLocation StartLoc, SourceLocation EndLoc)
-      : OMPClause(OMPC_unified_shared_memory, StartLoc, EndLoc) {}
+      : OMPClause(llvm::omp::OMPC_unified_shared_memory, StartLoc, EndLoc) {}
 
   /// Build an empty clause.
   OMPUnifiedSharedMemoryClause()
-      : OMPClause(OMPC_unified_shared_memory, SourceLocation(), SourceLocation()) {}
+      : OMPClause(llvm::omp::OMPC_unified_shared_memory, 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() == OMPC_unified_shared_memory;
+    return T->getClauseKind() == llvm::omp::OMPC_unified_shared_memory;
   }
 };
 
 /// This represents 'reverse_offload' clause in the '#pragma omp requires'
 /// directive.
 ///
 /// \code
 /// #pragma omp requires reverse_offload
 /// \endcode
 /// In this example directive '#pragma omp requires' has 'reverse_offload'
 /// clause.
 class OMPReverseOffloadClause final : public OMPClause {
 public:
   friend class OMPClauseReader;
   /// Build 'reverse_offload' clause.
   ///
   /// \param StartLoc Starting location of the clause.
   /// \param EndLoc Ending location of the clause.
   OMPReverseOffloadClause(SourceLocation StartLoc, SourceLocation EndLoc)
-      : OMPClause(OMPC_reverse_offload, StartLoc, EndLoc) {}
+      : OMPClause(llvm::omp::OMPC_reverse_offload, StartLoc, EndLoc) {}
 
   /// Build an empty clause.
   OMPReverseOffloadClause()
-      : OMPClause(OMPC_reverse_offload, SourceLocation(), SourceLocation()) {}
+      : OMPClause(llvm::omp::OMPC_reverse_offload, 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() == OMPC_reverse_offload;
+    return T->getClauseKind() == llvm::omp::OMPC_reverse_offload;
   }
 };
 
 /// This represents 'dynamic_allocators' clause in the '#pragma omp requires'
 /// directive.
 ///
 /// \code
 /// #pragma omp requires dynamic_allocators
 /// \endcode
 /// In this example directive '#pragma omp requires' has 'dynamic_allocators'
 /// clause.
 class OMPDynamicAllocatorsClause final : public OMPClause {
 public:
   friend class OMPClauseReader;
   /// Build 'dynamic_allocators' clause.
   ///
   /// \param StartLoc Starting location of the clause.
   /// \param EndLoc Ending location of the clause.
   OMPDynamicAllocatorsClause(SourceLocation StartLoc, SourceLocation EndLoc)
-      : OMPClause(OMPC_dynamic_allocators, StartLoc, EndLoc) {}
+      : OMPClause(llvm::omp::OMPC_dynamic_allocators, StartLoc, EndLoc) {}
 
   /// Build an empty clause.
   OMPDynamicAllocatorsClause()
-      : OMPClause(OMPC_dynamic_allocators, SourceLocation(), SourceLocation()) {
-  }
+      : OMPClause(llvm::omp::OMPC_dynamic_allocators, 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() == OMPC_dynamic_allocators;
+    return T->getClauseKind() == llvm::omp::OMPC_dynamic_allocators;
   }
 };
 
 /// This represents 'atomic_default_mem_order' clause in the '#pragma omp
 /// requires'  directive.
 ///
 /// \code
 /// #pragma omp requires atomic_default_mem_order(seq_cst)
public:
   /// \param ALoc Starting location of the argument.
   /// \param StartLoc Starting location of the clause.
   /// \param LParenLoc Location of '('.
   /// \param EndLoc Ending location of the clause.
   OMPAtomicDefaultMemOrderClause(OpenMPAtomicDefaultMemOrderClauseKind A,
                                  SourceLocation ALoc, SourceLocation StartLoc,
                                  SourceLocation LParenLoc,
                                  SourceLocation EndLoc)
-      : OMPClause(OMPC_atomic_default_mem_order, StartLoc, EndLoc),
+      : OMPClause(llvm::omp::OMPC_atomic_default_mem_order, StartLoc, EndLoc),
         LParenLoc(LParenLoc), Kind(A), KindKwLoc(ALoc) {}
 
   /// Build an empty clause.
   OMPAtomicDefaultMemOrderClause()
-      : OMPClause(OMPC_atomic_default_mem_order, SourceLocation(),
+      : OMPClause(llvm::omp::OMPC_atomic_default_mem_order, SourceLocation(),
                   SourceLocation()) {}
 
   /// Sets the location of '('.
   void setLParenLoc(SourceLocation Loc) { LParenLoc = Loc; }
 
   /// Returns the locaiton of '('.
   SourceLocation getLParenLoc() const { return LParenLoc; }
 
public:
   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() == OMPC_atomic_default_mem_order;
+    return T->getClauseKind() == llvm::omp::OMPC_atomic_default_mem_order;
   }
 };
 
 /// This represents 'schedule' clause in the '#pragma omp ...' directive.
 ///
 /// \code
 /// #pragma omp for schedule(static, 3)
 /// \endcode
public:
   /// \param M2 The second modifier applied to 'schedule' clause.
   /// \param M2Loc Location of the second modifier
   OMPScheduleClause(SourceLocation StartLoc, SourceLocation LParenLoc,
                     SourceLocation KLoc, SourceLocation CommaLoc,
                     SourceLocation EndLoc, OpenMPScheduleClauseKind Kind,
                     Expr *ChunkSize, Stmt *HelperChunkSize,
                     OpenMPScheduleClauseModifier M1, SourceLocation M1Loc,
                     OpenMPScheduleClauseModifier M2, SourceLocation M2Loc)
-      : OMPClause(OMPC_schedule, StartLoc, EndLoc), OMPClauseWithPreInit(this),
-        LParenLoc(LParenLoc), Kind(Kind), KindLoc(KLoc), CommaLoc(CommaLoc),
-        ChunkSize(ChunkSize) {
+      : OMPClause(llvm::omp::OMPC_schedule, StartLoc, EndLoc),
+        OMPClauseWithPreInit(this), LParenLoc(LParenLoc), Kind(Kind),
+        KindLoc(KLoc), CommaLoc(CommaLoc), ChunkSize(ChunkSize) {
     setPreInitStmt(HelperChunkSize);
     Modifiers[FIRST] = M1;
     Modifiers[SECOND] = M2;
     ModifiersLoc[FIRST] = M1Loc;
     ModifiersLoc[SECOND] = M2Loc;
   }
 
   /// Build an empty clause.
   explicit OMPScheduleClause()
-      : OMPClause(OMPC_schedule, SourceLocation(), SourceLocation()),
+      : OMPClause(llvm::omp::OMPC_schedule, SourceLocation(), SourceLocation()),
         OMPClauseWithPreInit(this) {
     Modifiers[FIRST] = OMPC_SCHEDULE_MODIFIER_unknown;
     Modifiers[SECOND] = OMPC_SCHEDULE_MODIFIER_unknown;
   }
 
   /// Get kind of the clause.
   OpenMPScheduleClauseKind getScheduleKind() const { return Kind; }
 
public:
   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() == OMPC_schedule;
+    return T->getClauseKind() == llvm::omp::OMPC_schedule;
   }
 };
 
 /// This represents 'ordered' clause in the '#pragma omp ...' directive.
 ///
 /// \code
 /// #pragma omp for ordered (2)
 /// \endcode
class OMPOrderedClause final
   ///
   /// \param Num Expression, possibly associated with this clause.
   /// \param NumLoops Number of loops, associated with this clause.
   /// \param StartLoc Starting location of the clause.
   /// \param LParenLoc Location of '('.
   /// \param EndLoc Ending location of the clause.
   OMPOrderedClause(Expr *Num, unsigned NumLoops, SourceLocation StartLoc,
                    SourceLocation LParenLoc, SourceLocation EndLoc)
-      : OMPClause(OMPC_ordered, StartLoc, EndLoc), LParenLoc(LParenLoc),
-        NumForLoops(Num), NumberOfLoops(NumLoops) {}
+      : OMPClause(llvm::omp::OMPC_ordered, StartLoc, EndLoc),
+        LParenLoc(LParenLoc), NumForLoops(Num), NumberOfLoops(NumLoops) {}
 
   /// Build an empty clause.
   explicit OMPOrderedClause(unsigned NumLoops)
-      : OMPClause(OMPC_ordered, SourceLocation(), SourceLocation()),
+      : OMPClause(llvm::omp::OMPC_ordered, SourceLocation(), SourceLocation()),
         NumberOfLoops(NumLoops) {}
 
   /// Set the number of associated for-loops.
   void setNumForLoops(Expr *Num) { NumForLoops = Num; }
 
 public:
   /// Build 'ordered' clause.
   ///
public:
   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() == OMPC_ordered;
+    return T->getClauseKind() == llvm::omp::OMPC_ordered;
   }
 };
 
 /// This represents 'nowait' clause in the '#pragma omp ...' directive.
 ///
 /// \code
 /// #pragma omp for nowait
 /// \endcode
 /// In this example directive '#pragma omp for' has 'nowait' clause.
 class OMPNowaitClause : public OMPClause {
 public:
   /// Build 'nowait' clause.
   ///
   /// \param StartLoc Starting location of the clause.
   /// \param EndLoc Ending location of the clause.
   OMPNowaitClause(SourceLocation StartLoc, SourceLocation EndLoc)
-      : OMPClause(OMPC_nowait, StartLoc, EndLoc) {}
+      : OMPClause(llvm::omp::OMPC_nowait, StartLoc, EndLoc) {}
 
   /// Build an empty clause.
   OMPNowaitClause()
-      : OMPClause(OMPC_nowait, SourceLocation(), SourceLocation()) {}
+      : OMPClause(llvm::omp::OMPC_nowait, 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() == OMPC_nowait;
+    return T->getClauseKind() == llvm::omp::OMPC_nowait;
   }
 };
 
 /// This represents 'untied' clause in the '#pragma omp ...' directive.
 ///
 /// \code
 /// #pragma omp task untied
 /// \endcode
 /// In this example directive '#pragma omp task' has 'untied' clause.
 class OMPUntiedClause : public OMPClause {
 public:
   /// Build 'untied' clause.
   ///
   /// \param StartLoc Starting location of the clause.
   /// \param EndLoc Ending location of the clause.
   OMPUntiedClause(SourceLocation StartLoc, SourceLocation EndLoc)
-      : OMPClause(OMPC_untied, StartLoc, EndLoc) {}
+      : OMPClause(llvm::omp::OMPC_untied, StartLoc, EndLoc) {}
 
   /// Build an empty clause.
   OMPUntiedClause()
-      : OMPClause(OMPC_untied, SourceLocation(), SourceLocation()) {}
+      : OMPClause(llvm::omp::OMPC_untied, 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() == OMPC_untied;
+    return T->getClauseKind() == llvm::omp::OMPC_untied;
   }
 };
 
 /// This represents 'mergeable' clause in the '#pragma omp ...'
 /// directive.
 ///
 /// \code
 /// #pragma omp task mergeable
 /// \endcode
 /// In this example directive '#pragma omp task' has 'mergeable' clause.
 class OMPMergeableClause : public OMPClause {
 public:
   /// Build 'mergeable' clause.
   ///
   /// \param StartLoc Starting location of the clause.
   /// \param EndLoc Ending location of the clause.
   OMPMergeableClause(SourceLocation StartLoc, SourceLocation EndLoc)
-      : OMPClause(OMPC_mergeable, StartLoc, EndLoc) {}
+      : OMPClause(llvm::omp::OMPC_mergeable, StartLoc, EndLoc) {}
 
   /// Build an empty clause.
   OMPMergeableClause()
-      : OMPClause(OMPC_mergeable, SourceLocation(), SourceLocation()) {}
+      : OMPClause(llvm::omp::OMPC_mergeable, 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() == OMPC_mergeable;
+    return T->getClauseKind() == llvm::omp::OMPC_mergeable;
   }
 };
 
 /// This represents 'read' clause in the '#pragma omp atomic' directive.
 ///
 /// \code
 /// #pragma omp atomic read
 /// \endcode
 /// In this example directive '#pragma omp atomic' has 'read' clause.
 class OMPReadClause : public OMPClause {
 public:
   /// Build 'read' clause.
   ///
   /// \param StartLoc Starting location of the clause.
   /// \param EndLoc Ending location of the clause.
   OMPReadClause(SourceLocation StartLoc, SourceLocation EndLoc)
-      : OMPClause(OMPC_read, StartLoc, EndLoc) {}
+      : OMPClause(llvm::omp::OMPC_read, StartLoc, EndLoc) {}
 
   /// Build an empty clause.
-  OMPReadClause() : OMPClause(OMPC_read, SourceLocation(), SourceLocation()) {}
+  OMPReadClause()
+      : OMPClause(llvm::omp::OMPC_read, 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() == OMPC_read;
+    return T->getClauseKind() == llvm::omp::OMPC_read;
   }
 };
 
 /// This represents 'write' clause in the '#pragma omp atomic' directive.
 ///
 /// \code
 /// #pragma omp atomic write
 /// \endcode
 /// In this example directive '#pragma omp atomic' has 'write' clause.
 class OMPWriteClause : public OMPClause {
 public:
   /// Build 'write' clause.
   ///
   /// \param StartLoc Starting location of the clause.
   /// \param EndLoc Ending location of the clause.
   OMPWriteClause(SourceLocation StartLoc, SourceLocation EndLoc)
-      : OMPClause(OMPC_write, StartLoc, EndLoc) {}
+      : OMPClause(llvm::omp::OMPC_write, StartLoc, EndLoc) {}
 
   /// Build an empty clause.
   OMPWriteClause()
-      : OMPClause(OMPC_write, SourceLocation(), SourceLocation()) {}
+      : OMPClause(llvm::omp::OMPC_write, 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() == OMPC_write;
+    return T->getClauseKind() == llvm::omp::OMPC_write;
   }
 };
 
 /// This represents 'update' clause in the '#pragma omp atomic'
 /// directive.
 ///
 /// \code
 /// #pragma omp atomic update
class OMPUpdateClause final
   }
 
   /// Build 'update' clause.
   ///
   /// \param StartLoc Starting location of the clause.
   /// \param EndLoc Ending location of the clause.
   OMPUpdateClause(SourceLocation StartLoc, SourceLocation EndLoc,
                   bool IsExtended)
-      : OMPClause(OMPC_update, StartLoc, EndLoc), IsExtended(IsExtended) {}
+      : OMPClause(llvm::omp::OMPC_update, StartLoc, EndLoc),
+        IsExtended(IsExtended) {}
 
   /// Build an empty clause.
   OMPUpdateClause(bool IsExtended)
-      : OMPClause(OMPC_update, SourceLocation(), SourceLocation()),
+      : OMPClause(llvm::omp::OMPC_update, SourceLocation(), SourceLocation()),
         IsExtended(IsExtended) {}
 
 public:
   /// Creates clause for 'atomic' directive.
   ///
   /// \param C AST context.
   /// \param StartLoc Starting location of the clause.
   /// \param EndLoc Ending location of the clause.
public:
 
   /// Gets the dependence kind in clause for 'depobj' directive.
   OpenMPDependClauseKind getDependencyKind() const {
     assert(IsExtended && "Expected extended clause.");
     return *getTrailingObjects<OpenMPDependClauseKind>();
   }
 
   static bool classof(const OMPClause *T) {
-    return T->getClauseKind() == OMPC_update;
+    return T->getClauseKind() == llvm::omp::OMPC_update;
   }
 };
 
 /// This represents 'capture' clause in the '#pragma omp atomic'
 /// directive.
 ///
 /// \code
 /// #pragma omp atomic capture
 /// \endcode
 /// In this example directive '#pragma omp atomic' has 'capture' clause.
 class OMPCaptureClause : public OMPClause {
 public:
   /// Build 'capture' clause.
   ///
   /// \param StartLoc Starting location of the clause.
   /// \param EndLoc Ending location of the clause.
   OMPCaptureClause(SourceLocation StartLoc, SourceLocation EndLoc)
-      : OMPClause(OMPC_capture, StartLoc, EndLoc) {}
+      : OMPClause(llvm::omp::OMPC_capture, StartLoc, EndLoc) {}
 
   /// Build an empty clause.
   OMPCaptureClause()
-      : OMPClause(OMPC_capture, SourceLocation(), SourceLocation()) {}
+      : OMPClause(llvm::omp::OMPC_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() == OMPC_capture;
+    return T->getClauseKind() == llvm::omp::OMPC_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 {
 public:
   /// Build 'seq_cst' clause.
   ///
   /// \param StartLoc Starting location of the clause.
   /// \param EndLoc Ending location of the clause.
   OMPSeqCstClause(SourceLocation StartLoc, SourceLocation EndLoc)
-      : OMPClause(OMPC_seq_cst, StartLoc, EndLoc) {}
+      : OMPClause(llvm::omp::OMPC_seq_cst, StartLoc, EndLoc) {}
 
   /// Build an empty clause.
   OMPSeqCstClause()
-      : OMPClause(OMPC_seq_cst, SourceLocation(), SourceLocation()) {}
+      : OMPClause(llvm::omp::OMPC_seq_cst, 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() == OMPC_seq_cst;
+    return T->getClauseKind() == llvm::omp::OMPC_seq_cst;
   }
 };
 
 /// This represents 'acq_rel' clause in the '#pragma omp atomic|flush'
 /// directives.
 ///
 /// \code
 /// #pragma omp flush acq_rel
 /// \endcode
 /// In this example directive '#pragma omp flush' has 'acq_rel' clause.
 class OMPAcqRelClause final : public OMPClause {
 public:
   /// Build 'ack_rel' clause.
   ///
   /// \param StartLoc Starting location of the clause.
   /// \param EndLoc Ending location of the clause.
   OMPAcqRelClause(SourceLocation StartLoc, SourceLocation EndLoc)
-      : OMPClause(OMPC_acq_rel, StartLoc, EndLoc) {}
+      : OMPClause(llvm::omp::OMPC_acq_rel, StartLoc, EndLoc) {}
 
   /// Build an empty clause.
   OMPAcqRelClause()
-      : OMPClause(OMPC_acq_rel, SourceLocation(), SourceLocation()) {}
+      : OMPClause(llvm::omp::OMPC_acq_rel, 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() == OMPC_acq_rel;
+    return T->getClauseKind() == llvm::omp::OMPC_acq_rel;
   }
 };
 
 /// This represents 'acquire' clause in the '#pragma omp atomic|flush'
 /// directives.
 ///
 /// \code
 /// #pragma omp flush acquire
 /// \endcode
 /// In this example directive '#pragma omp flush' has 'acquire' clause.
 class OMPAcquireClause final : public OMPClause {
 public:
   /// Build 'acquire' clause.
   ///
   /// \param StartLoc Starting location of the clause.
   /// \param EndLoc Ending location of the clause.
   OMPAcquireClause(SourceLocation StartLoc, SourceLocation EndLoc)
-      : OMPClause(OMPC_acquire, StartLoc, EndLoc) {}
+      : OMPClause(llvm::omp::OMPC_acquire, StartLoc, EndLoc) {}
 
   /// Build an empty clause.
   OMPAcquireClause()
-      : OMPClause(OMPC_acquire, SourceLocation(), SourceLocation()) {}
+      : OMPClause(llvm::omp::OMPC_acquire, 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() == OMPC_acquire;
+    return T->getClauseKind() == llvm::omp::OMPC_acquire;
   }
 };
 
 /// This represents 'release' clause in the '#pragma omp atomic|flush'
 /// directives.
 ///
 /// \code
 /// #pragma omp flush release
 /// \endcode
 /// In this example directive '#pragma omp flush' has 'release' clause.
 class OMPReleaseClause final : public OMPClause {
 public:
   /// Build 'release' clause.
   ///
   /// \param StartLoc Starting location of the clause.
   /// \param EndLoc Ending location of the clause.
   OMPReleaseClause(SourceLocation StartLoc, SourceLocation EndLoc)
-      : OMPClause(OMPC_release, StartLoc, EndLoc) {}
+      : OMPClause(llvm::omp::OMPC_release, StartLoc, EndLoc) {}
 
   /// Build an empty clause.
   OMPReleaseClause()
-      : OMPClause(OMPC_release, SourceLocation(), SourceLocation()) {}
+      : OMPClause(llvm::omp::OMPC_release, 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() == OMPC_release;
+    return T->getClauseKind() == llvm::omp::OMPC_release;
   }
 };
 
 /// This represents 'relaxed' clause in the '#pragma omp atomic'
 /// directives.
 ///
 /// \code
 /// #pragma omp atomic relaxed
 /// \endcode
 /// In this example directive '#pragma omp atomic' has 'relaxed' clause.
 class OMPRelaxedClause final : public OMPClause {
 public:
   /// Build 'relaxed' clause.
   ///
   /// \param StartLoc Starting location of the clause.
   /// \param EndLoc Ending location of the clause.
   OMPRelaxedClause(SourceLocation StartLoc, SourceLocation EndLoc)
-      : OMPClause(OMPC_relaxed, StartLoc, EndLoc) {}
+      : OMPClause(llvm::omp::OMPC_relaxed, StartLoc, EndLoc) {}
 
   /// Build an empty clause.
   OMPRelaxedClause()
-      : OMPClause(OMPC_relaxed, SourceLocation(), SourceLocation()) {}
+      : OMPClause(llvm::omp::OMPC_relaxed, 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() == OMPC_relaxed;
+    return T->getClauseKind() == llvm::omp::OMPC_relaxed;
   }
 };
 
 /// This represents clause 'private' in the '#pragma omp ...' directives.
 ///
 /// \code
 /// #pragma omp parallel private(a,b)
 /// \endcode
class OMPPrivateClause final
   /// Build clause with number of variables \a N.
   ///
   /// \param StartLoc Starting location of the clause.
   /// \param LParenLoc Location of '('.
   /// \param EndLoc Ending location of the clause.
   /// \param N Number of the variables in the clause.
   OMPPrivateClause(SourceLocation StartLoc, SourceLocation LParenLoc,
                    SourceLocation EndLoc, unsigned N)
-      : OMPVarListClause<OMPPrivateClause>(OMPC_private, StartLoc, LParenLoc,
-                                           EndLoc, N) {}
+      : OMPVarListClause<OMPPrivateClause>(llvm::omp::OMPC_private, StartLoc,
+                                           LParenLoc, EndLoc, N) {}
 
   /// Build an empty clause.
   ///
   /// \param N Number of variables.
   explicit OMPPrivateClause(unsigned N)
-      : OMPVarListClause<OMPPrivateClause>(OMPC_private, SourceLocation(),
+      : OMPVarListClause<OMPPrivateClause>(llvm::omp::OMPC_private,
                                            SourceLocation(), SourceLocation(),
-                                           N) {}
+                                           SourceLocation(), N) {}
 
   /// Sets the list of references to private copies with initializers for
   /// new private variables.
   /// \param VL List of references.
   void setPrivateCopies(ArrayRef<Expr *> VL);
 
   /// Gets the list of references to private copies with initializers for
   /// new private variables.
public:
   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() == OMPC_private;
+    return T->getClauseKind() == llvm::omp::OMPC_private;
   }
 };
 
 /// This represents clause 'firstprivate' in the '#pragma omp ...'
 /// directives.
 ///
 /// \code
 /// #pragma omp parallel firstprivate(a,b)
class OMPFirstprivateClause final
   /// Build clause with number of variables \a N.
   ///
   /// \param StartLoc Starting location of the clause.
   /// \param LParenLoc Location of '('.
   /// \param EndLoc Ending location of the clause.
   /// \param N Number of the variables in the clause.
   OMPFirstprivateClause(SourceLocation StartLoc, SourceLocation LParenLoc,
                         SourceLocation EndLoc, unsigned N)
-      : OMPVarListClause<OMPFirstprivateClause>(OMPC_firstprivate, StartLoc,
-                                                LParenLoc, EndLoc, N),
+      : OMPVarListClause<OMPFirstprivateClause>(llvm::omp::OMPC_firstprivate,
+                                                StartLoc, LParenLoc, EndLoc, N),
         OMPClauseWithPreInit(this) {}
 
   /// Build an empty clause.
   ///
   /// \param N Number of variables.
   explicit OMPFirstprivateClause(unsigned N)
       : OMPVarListClause<OMPFirstprivateClause>(
-            OMPC_firstprivate, SourceLocation(), SourceLocation(),
+            llvm::omp::OMPC_firstprivate, SourceLocation(), SourceLocation(),
             SourceLocation(), N),
         OMPClauseWithPreInit(this) {}
 
   /// Sets the list of references to private copies with initializers for
   /// new private variables.
   /// \param VL List of references.
   void setPrivateCopies(ArrayRef<Expr *> VL);
 
return child_range(reinterpret_cast<Stmt **>(varlist_begin()),
                        reinterpret_cast<Stmt **>(varlist_end()));
   }
   const_child_range used_children() const {
     auto Children = const_cast<OMPFirstprivateClause *>(this)->used_children();
     return const_child_range(Children.begin(), Children.end());
   }
 
   static bool classof(const OMPClause *T) {
-    return T->getClauseKind() == OMPC_firstprivate;
+    return T->getClauseKind() == llvm::omp::OMPC_firstprivate;
   }
 };
 
 /// This represents clause 'lastprivate' in the '#pragma omp ...'
 /// directives.
 ///
 /// \code
 /// #pragma omp simd lastprivate(a,b)
class OMPLastprivateClause final
   /// \param StartLoc Starting location of the clause.
   /// \param LParenLoc Location of '('.
   /// \param EndLoc Ending location of the clause.
   /// \param N Number of the variables in the clause.
   OMPLastprivateClause(SourceLocation StartLoc, SourceLocation LParenLoc,
                        SourceLocation EndLoc, OpenMPLastprivateModifier LPKind,
                        SourceLocation LPKindLoc, SourceLocation ColonLoc,
                        unsigned N)
-      : OMPVarListClause<OMPLastprivateClause>(OMPC_lastprivate, StartLoc,
-                                               LParenLoc, EndLoc, N),
+      : OMPVarListClause<OMPLastprivateClause>(llvm::omp::OMPC_lastprivate,
+                                               StartLoc, LParenLoc, EndLoc, N),
         OMPClauseWithPostUpdate(this), LPKind(LPKind), LPKindLoc(LPKindLoc),
         ColonLoc(ColonLoc) {}
 
   /// Build an empty clause.
   ///
   /// \param N Number of variables.
   explicit OMPLastprivateClause(unsigned N)
       : OMPVarListClause<OMPLastprivateClause>(
-            OMPC_lastprivate, SourceLocation(), SourceLocation(),
+            llvm::omp::OMPC_lastprivate, SourceLocation(), SourceLocation(),
             SourceLocation(), N),
         OMPClauseWithPostUpdate(this) {}
 
   /// Get the list of helper expressions for initialization of private
   /// copies for lastprivate variables.
   MutableArrayRef<Expr *> getPrivateCopies() {
     return MutableArrayRef<Expr *>(varlist_end(), varlist_size());
   }
public:
   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() == OMPC_lastprivate;
+    return T->getClauseKind() == llvm::omp::OMPC_lastprivate;
   }
 };
 
 /// This represents clause 'shared' in the '#pragma omp ...' directives.
 ///
 /// \code
 /// #pragma omp parallel shared(a,b)
 /// \endcode
 /// In this example directive '#pragma omp parallel' has clause 'shared'
 /// with the variables 'a' and 'b'.
 class OMPSharedClause final
     : public OMPVarListClause<OMPSharedClause>,
       private llvm::TrailingObjects<OMPSharedClause, Expr *> {
   friend OMPVarListClause;
   friend TrailingObjects;
 
   /// Build clause with number of variables \a N.
   ///
   /// \param StartLoc Starting location of the clause.
   /// \param LParenLoc Location of '('.
   /// \param EndLoc Ending location of the clause.
   /// \param N Number of the variables in the clause.
   OMPSharedClause(SourceLocation StartLoc, SourceLocation LParenLoc,
                   SourceLocation EndLoc, unsigned N)
-      : OMPVarListClause<OMPSharedClause>(OMPC_shared, StartLoc, LParenLoc,
-                                          EndLoc, N) {}
+      : OMPVarListClause<OMPSharedClause>(llvm::omp::OMPC_shared, StartLoc,
+                                          LParenLoc, EndLoc, N) {}
 
   /// Build an empty clause.
   ///
   /// \param N Number of variables.
   explicit OMPSharedClause(unsigned N)
-      : OMPVarListClause<OMPSharedClause>(OMPC_shared, SourceLocation(),
+      : OMPVarListClause<OMPSharedClause>(llvm::omp::OMPC_shared,
                                           SourceLocation(), SourceLocation(),
-                                          N) {}
+                                          SourceLocation(), N) {}
 
 public:
   /// Creates clause with a list of variables \a VL.
   ///
   /// \param C AST context.
   /// \param StartLoc Starting location of the clause.
   /// \param LParenLoc Location of '('.
   /// \param EndLoc Ending location of the clause.
public:
   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() == OMPC_shared;
+    return T->getClauseKind() == llvm::omp::OMPC_shared;
   }
 };
 
 /// This represents clause 'reduction' in the '#pragma omp ...'
 /// directives.
 ///
 /// \code
 /// #pragma omp parallel reduction(+:a,b)
class OMPReductionClause final
   /// \param QualifierLoc The nested-name qualifier with location information
   /// \param NameInfo The full name info for reduction identifier.
   OMPReductionClause(SourceLocation StartLoc, SourceLocation LParenLoc,
                      SourceLocation ModifierLoc, SourceLocation ColonLoc,
                      SourceLocation EndLoc,
                      OpenMPReductionClauseModifier Modifier, unsigned N,
                      NestedNameSpecifierLoc QualifierLoc,
                      const DeclarationNameInfo &NameInfo)
-      : OMPVarListClause<OMPReductionClause>(OMPC_reduction, StartLoc,
-                                             LParenLoc, EndLoc, N),
+      : OMPVarListClause<OMPReductionClause>(llvm::omp::OMPC_reduction,
+                                             StartLoc, LParenLoc, EndLoc, N),
         OMPClauseWithPostUpdate(this), Modifier(Modifier),
         ModifierLoc(ModifierLoc), ColonLoc(ColonLoc),
         QualifierLoc(QualifierLoc), NameInfo(NameInfo) {}
 
   /// Build an empty clause.
   ///
   /// \param N Number of variables.
   explicit OMPReductionClause(unsigned N)
-      : OMPVarListClause<OMPReductionClause>(OMPC_reduction, SourceLocation(),
+      : OMPVarListClause<OMPReductionClause>(llvm::omp::OMPC_reduction,
                                              SourceLocation(), SourceLocation(),
-                                             N),
+                                             SourceLocation(), N),
         OMPClauseWithPostUpdate(this) {}
 
   /// Sets reduction modifier.
   void setModifier(OpenMPReductionClauseModifier M) { Modifier = M; }
 
   /// Sets location of the modifier.
   void setModifierLoc(SourceLocation Loc) { ModifierLoc = Loc; }
 
return child_range(reinterpret_cast<Stmt **>(varlist_begin()),
                        reinterpret_cast<Stmt **>(varlist_end()));
   }
   const_child_range used_children() const {
     auto Children = const_cast<OMPReductionClause *>(this)->used_children();
     return const_child_range(Children.begin(), Children.end());
   }
 
   static bool classof(const OMPClause *T) {
-    return T->getClauseKind() == OMPC_reduction;
+    return T->getClauseKind() == llvm::omp::OMPC_reduction;
   }
 };
 
 /// This represents clause 'task_reduction' in the '#pragma omp taskgroup'
 /// directives.
 ///
 /// \code
 /// #pragma omp taskgroup task_reduction(+:a,b)
class OMPTaskReductionClause final
   /// \param ColonLoc Location of ':'.
   /// \param N Number of the variables in the clause.
   /// \param QualifierLoc The nested-name qualifier with location information
   /// \param NameInfo The full name info for reduction identifier.
   OMPTaskReductionClause(SourceLocation StartLoc, SourceLocation LParenLoc,
                          SourceLocation ColonLoc, SourceLocation EndLoc,
                          unsigned N, NestedNameSpecifierLoc QualifierLoc,
                          const DeclarationNameInfo &NameInfo)
-      : OMPVarListClause<OMPTaskReductionClause>(OMPC_task_reduction, StartLoc,
-                                                 LParenLoc, EndLoc, N),
+      : OMPVarListClause<OMPTaskReductionClause>(
+            llvm::omp::OMPC_task_reduction, StartLoc, LParenLoc, EndLoc, N),
         OMPClauseWithPostUpdate(this), ColonLoc(ColonLoc),
         QualifierLoc(QualifierLoc), NameInfo(NameInfo) {}
 
   /// Build an empty clause.
   ///
   /// \param N Number of variables.
   explicit OMPTaskReductionClause(unsigned N)
       : OMPVarListClause<OMPTaskReductionClause>(
-            OMPC_task_reduction, SourceLocation(), SourceLocation(),
+            llvm::omp::OMPC_task_reduction, SourceLocation(), SourceLocation(),
             SourceLocation(), N),
         OMPClauseWithPostUpdate(this) {}
 
   /// Sets location of ':' symbol in clause.
   void setColonLoc(SourceLocation CL) { ColonLoc = CL; }
 
   /// Sets the name info for specified reduction identifier.
   void setNameInfo(DeclarationNameInfo DNI) { NameInfo = DNI; }
public:
   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() == OMPC_task_reduction;
+    return T->getClauseKind() == llvm::omp::OMPC_task_reduction;
   }
 };
 
 /// This represents clause 'in_reduction' in the '#pragma omp task' directives.
 ///
 /// \code
 /// #pragma omp task in_reduction(+:a,b)
 /// \endcode
class OMPInReductionClause final
   /// \param ColonLoc Location of ':'.
   /// \param N Number of the variables in the clause.
   /// \param QualifierLoc The nested-name qualifier with location information
   /// \param NameInfo The full name info for reduction identifier.
   OMPInReductionClause(SourceLocation StartLoc, SourceLocation LParenLoc,
                        SourceLocation ColonLoc, SourceLocation EndLoc,
                        unsigned N, NestedNameSpecifierLoc QualifierLoc,
                        const DeclarationNameInfo &NameInfo)
-      : OMPVarListClause<OMPInReductionClause>(OMPC_in_reduction, StartLoc,
-                                               LParenLoc, EndLoc, N),
+      : OMPVarListClause<OMPInReductionClause>(llvm::omp::OMPC_in_reduction,
+                                               StartLoc, LParenLoc, EndLoc, N),
         OMPClauseWithPostUpdate(this), ColonLoc(ColonLoc),
         QualifierLoc(QualifierLoc), NameInfo(NameInfo) {}
 
   /// Build an empty clause.
   ///
   /// \param N Number of variables.
   explicit OMPInReductionClause(unsigned N)
       : OMPVarListClause<OMPInReductionClause>(
-            OMPC_in_reduction, SourceLocation(), SourceLocation(),
+            llvm::omp::OMPC_in_reduction, SourceLocation(), SourceLocation(),
             SourceLocation(), N),
         OMPClauseWithPostUpdate(this) {}
 
   /// Sets location of ':' symbol in clause.
   void setColonLoc(SourceLocation CL) { ColonLoc = CL; }
 
   /// Sets the name info for specified reduction identifier.
   void setNameInfo(DeclarationNameInfo DNI) { NameInfo = DNI; }
public:
   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() == OMPC_in_reduction;
+    return T->getClauseKind() == llvm::omp::OMPC_in_reduction;
   }
 };
 
 /// This represents clause 'linear' in the '#pragma omp ...'
 /// directives.
 ///
 /// \code
 /// #pragma omp simd linear(a,b : 2)
class OMPLinearClause final
   /// \param LParenLoc Location of '('.
   /// \param ColonLoc Location of ':'.
   /// \param EndLoc Ending location of the clause.
   /// \param NumVars Number of variables.
   OMPLinearClause(SourceLocation StartLoc, SourceLocation LParenLoc,
                   OpenMPLinearClauseKind Modifier, SourceLocation ModifierLoc,
                   SourceLocation ColonLoc, SourceLocation EndLoc,
                   unsigned NumVars)
-      : OMPVarListClause<OMPLinearClause>(OMPC_linear, StartLoc, LParenLoc,
-                                          EndLoc, NumVars),
+      : OMPVarListClause<OMPLinearClause>(llvm::omp::OMPC_linear, StartLoc,
+                                          LParenLoc, EndLoc, NumVars),
         OMPClauseWithPostUpdate(this), Modifier(Modifier),
         ModifierLoc(ModifierLoc), ColonLoc(ColonLoc) {}
 
   /// Build an empty clause.
   ///
   /// \param NumVars Number of variables.
   explicit OMPLinearClause(unsigned NumVars)
-      : OMPVarListClause<OMPLinearClause>(OMPC_linear, SourceLocation(),
+      : OMPVarListClause<OMPLinearClause>(llvm::omp::OMPC_linear,
                                           SourceLocation(), SourceLocation(),
-                                          NumVars),
+                                          SourceLocation(), NumVars),
         OMPClauseWithPostUpdate(this) {}
 
   /// Gets the list of initial values for linear variables.
   ///
   /// There are NumVars expressions with initial values allocated after the
   /// varlist, they are followed by NumVars update expressions (used to update
   /// the linear variable's value on current iteration) and they are followed by
   /// NumVars final expressions (used to calculate the linear variable's
public:
   child_range used_children();
 
   const_child_range used_children() const {
     auto Children = const_cast<OMPLinearClause *>(this)->used_children();
     return const_child_range(Children.begin(), Children.end());
   }
 
   static bool classof(const OMPClause *T) {
-    return T->getClauseKind() == OMPC_linear;
+    return T->getClauseKind() == llvm::omp::OMPC_linear;
   }
 };
 
 /// This represents clause 'aligned' in the '#pragma omp ...'
 /// directives.
 ///
 /// \code
 /// #pragma omp simd aligned(a,b : 8)
class OMPAlignedClause final
   /// \param StartLoc Starting location of the clause.
   /// \param LParenLoc Location of '('.
   /// \param ColonLoc Location of ':'.
   /// \param EndLoc Ending location of the clause.
   /// \param NumVars Number of variables.
   OMPAlignedClause(SourceLocation StartLoc, SourceLocation LParenLoc,
                    SourceLocation ColonLoc, SourceLocation EndLoc,
                    unsigned NumVars)
-      : OMPVarListClause<OMPAlignedClause>(OMPC_aligned, StartLoc, LParenLoc,
-                                           EndLoc, NumVars),
+      : OMPVarListClause<OMPAlignedClause>(llvm::omp::OMPC_aligned, StartLoc,
+                                           LParenLoc, EndLoc, NumVars),
         ColonLoc(ColonLoc) {}
 
   /// Build an empty clause.
   ///
   /// \param NumVars Number of variables.
   explicit OMPAlignedClause(unsigned NumVars)
-      : OMPVarListClause<OMPAlignedClause>(OMPC_aligned, SourceLocation(),
+      : OMPVarListClause<OMPAlignedClause>(llvm::omp::OMPC_aligned,
                                            SourceLocation(), SourceLocation(),
-                                           NumVars) {}
+                                           SourceLocation(), NumVars) {}
 
 public:
   /// Creates clause with a list of variables \a VL and alignment \a A.
   ///
   /// \param C AST Context.
   /// \param StartLoc Starting location of the clause.
   /// \param LParenLoc Location of '('.
   /// \param ColonLoc Location of ':'.
public:
   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() == OMPC_aligned;
+    return T->getClauseKind() == llvm::omp::OMPC_aligned;
   }
 };
 
 /// This represents clause 'copyin' in the '#pragma omp ...' directives.
 ///
 /// \code
 /// #pragma omp parallel copyin(a,b)
 /// \endcode
class OMPCopyinClause final
   /// Build clause with number of variables \a N.
   ///
   /// \param StartLoc Starting location of the clause.
   /// \param LParenLoc Location of '('.
   /// \param EndLoc Ending location of the clause.
   /// \param N Number of the variables in the clause.
   OMPCopyinClause(SourceLocation StartLoc, SourceLocation LParenLoc,
                   SourceLocation EndLoc, unsigned N)
-      : OMPVarListClause<OMPCopyinClause>(OMPC_copyin, StartLoc, LParenLoc,
-                                          EndLoc, N) {}
+      : OMPVarListClause<OMPCopyinClause>(llvm::omp::OMPC_copyin, StartLoc,
+                                          LParenLoc, EndLoc, N) {}
 
   /// Build an empty clause.
   ///
   /// \param N Number of variables.
   explicit OMPCopyinClause(unsigned N)
-      : OMPVarListClause<OMPCopyinClause>(OMPC_copyin, SourceLocation(),
+      : OMPVarListClause<OMPCopyinClause>(llvm::omp::OMPC_copyin,
                                           SourceLocation(), SourceLocation(),
-                                          N) {}
+                                          SourceLocation(), N) {}
 
   /// Set list of helper expressions, required for proper codegen of the
   /// clause. These expressions represent source expression in the final
   /// assignment statement performed by the copyin clause.
   void setSourceExprs(ArrayRef<Expr *> SrcExprs);
 
   /// Get the list of helper source expressions.
   MutableArrayRef<Expr *> getSourceExprs() {
public:
   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() == OMPC_copyin;
+    return T->getClauseKind() == llvm::omp::OMPC_copyin;
   }
 };
 
 /// This represents clause 'copyprivate' in the '#pragma omp ...'
 /// directives.
 ///
 /// \code
 /// #pragma omp single copyprivate(a,b)
class OMPCopyprivateClause final
   /// Build clause with number of variables \a N.
   ///
   /// \param StartLoc Starting location of the clause.
   /// \param LParenLoc Location of '('.
   /// \param EndLoc Ending location of the clause.
   /// \param N Number of the variables in the clause.
   OMPCopyprivateClause(SourceLocation StartLoc, SourceLocation LParenLoc,
                        SourceLocation EndLoc, unsigned N)
-      : OMPVarListClause<OMPCopyprivateClause>(OMPC_copyprivate, StartLoc,
-                                               LParenLoc, EndLoc, N) {}
+      : OMPVarListClause<OMPCopyprivateClause>(llvm::omp::OMPC_copyprivate,
+                                               StartLoc, LParenLoc, EndLoc, N) {
+  }
 
   /// Build an empty clause.
   ///
   /// \param N Number of variables.
   explicit OMPCopyprivateClause(unsigned N)
       : OMPVarListClause<OMPCopyprivateClause>(
-            OMPC_copyprivate, SourceLocation(), SourceLocation(),
+            llvm::omp::OMPC_copyprivate, SourceLocation(), SourceLocation(),
             SourceLocation(), N) {}
 
   /// Set list of helper expressions, required for proper codegen of the
   /// clause. These expressions represent source expression in the final
   /// assignment statement performed by the copyprivate clause.
   void setSourceExprs(ArrayRef<Expr *> SrcExprs);
 
   /// Get the list of helper source expressions.
public:
   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() == OMPC_copyprivate;
+    return T->getClauseKind() == llvm::omp::OMPC_copyprivate;
   }
 };
 
 /// This represents implicit clause 'flush' for the '#pragma omp flush'
 /// directive.
 /// This clause does not exist by itself, it can be only as a part of 'omp
 /// flush' directive. This clause is introduced to keep the original structure
 /// of \a OMPExecutableDirective class and its derivatives and to use the
class OMPFlushClause final
   /// Build clause with number of variables \a N.
   ///
   /// \param StartLoc Starting location of the clause.
   /// \param LParenLoc Location of '('.
   /// \param EndLoc Ending location of the clause.
   /// \param N Number of the variables in the clause.
   OMPFlushClause(SourceLocation StartLoc, SourceLocation LParenLoc,
                  SourceLocation EndLoc, unsigned N)
-      : OMPVarListClause<OMPFlushClause>(OMPC_flush, StartLoc, LParenLoc,
-                                         EndLoc, N) {}
+      : OMPVarListClause<OMPFlushClause>(llvm::omp::OMPC_flush, StartLoc,
+                                         LParenLoc, EndLoc, N) {}
 
   /// Build an empty clause.
   ///
   /// \param N Number of variables.
   explicit OMPFlushClause(unsigned N)
-      : OMPVarListClause<OMPFlushClause>(OMPC_flush, SourceLocation(),
+      : OMPVarListClause<OMPFlushClause>(llvm::omp::OMPC_flush,
                                          SourceLocation(), SourceLocation(),
-                                         N) {}
+                                         SourceLocation(), N) {}
 
 public:
   /// Creates clause with a list of variables \a VL.
   ///
   /// \param C AST context.
   /// \param StartLoc Starting location of the clause.
   /// \param LParenLoc Location of '('.
   /// \param EndLoc Ending location of the clause.
public:
   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() == OMPC_flush;
+    return T->getClauseKind() == llvm::omp::OMPC_flush;
   }
 };
 
 /// This represents implicit clause 'depobj' for the '#pragma omp depobj'
 /// directive.
 /// This clause does not exist by itself, it can be only as a part of 'omp
 /// depobj' directive. This clause is introduced to keep the original structure
 /// of \a OMPExecutableDirective class and its derivatives and to use the
class OMPDepobjClause final : public OMPClause {
 
   /// Build clause with number of variables \a N.
   ///
   /// \param StartLoc Starting location of the clause.
   /// \param LParenLoc Location of '('.
   /// \param EndLoc Ending location of the clause.
   OMPDepobjClause(SourceLocation StartLoc, SourceLocation LParenLoc,
                   SourceLocation EndLoc)
-      : OMPClause(OMPC_depobj, StartLoc, EndLoc), LParenLoc(LParenLoc) {}
+      : OMPClause(llvm::omp::OMPC_depobj, StartLoc, EndLoc),
+        LParenLoc(LParenLoc) {}
 
   /// Build an empty clause.
   ///
   explicit OMPDepobjClause()
-      : OMPClause(OMPC_depobj, SourceLocation(), SourceLocation()) {}
+      : OMPClause(llvm::omp::OMPC_depobj, SourceLocation(), SourceLocation()) {}
 
   void setDepobj(Expr *E) { Depobj = E; }
 
   /// Sets the location of '('.
   void setLParenLoc(SourceLocation Loc) { LParenLoc = Loc; }
 
 public:
   /// Creates clause.
public:
   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() == OMPC_depobj;
+    return T->getClauseKind() == llvm::omp::OMPC_depobj;
   }
 };
 
 /// This represents implicit clause 'depend' for the '#pragma omp task'
 /// directive.
 ///
 /// \code
 /// #pragma omp task depend(in:a,b)
class OMPDependClause final
   /// \param StartLoc Starting location of the clause.
   /// \param LParenLoc Location of '('.
   /// \param EndLoc Ending location of the clause.
   /// \param N Number of the variables in the clause.
   /// \param NumLoops Number of loops that is associated with this depend
   /// clause.
   OMPDependClause(SourceLocation StartLoc, SourceLocation LParenLoc,
                   SourceLocation EndLoc, unsigned N, unsigned NumLoops)
-      : OMPVarListClause<OMPDependClause>(OMPC_depend, StartLoc, LParenLoc,
-                                          EndLoc, N), NumLoops(NumLoops) {}
+      : OMPVarListClause<OMPDependClause>(llvm::omp::OMPC_depend, StartLoc,
+                                          LParenLoc, EndLoc, N),
+        NumLoops(NumLoops) {}
 
   /// Build an empty clause.
   ///
   /// \param N Number of variables.
   /// \param NumLoops Number of loops that is associated with this depend
   /// clause.
   explicit OMPDependClause(unsigned N, unsigned NumLoops)
-      : OMPVarListClause<OMPDependClause>(OMPC_depend, SourceLocation(),
+      : OMPVarListClause<OMPDependClause>(llvm::omp::OMPC_depend,
                                           SourceLocation(), SourceLocation(),
-                                          N),
+                                          SourceLocation(), N),
         NumLoops(NumLoops) {}
 
   /// Set dependency kind.
   void setDependencyKind(OpenMPDependClauseKind K) { DepKind = K; }
 
   /// Set dependency kind and its location.
   void setDependencyLoc(SourceLocation Loc) { DepLoc = Loc; }
 
public:
   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() == OMPC_depend;
+    return T->getClauseKind() == llvm::omp::OMPC_depend;
   }
 };
 
 /// This represents 'device' clause in the '#pragma omp ...'
 /// directive.
 ///
 /// \code
 /// #pragma omp target device(a)
public:
   /// \param StartLoc Starting location of the clause.
   /// \param ModifierLoc Modifier location.
   /// \param LParenLoc Location of '('.
   /// \param EndLoc Ending location of the clause.
   OMPDeviceClause(OpenMPDeviceClauseModifier Modifier, Expr *E, Stmt *HelperE,
                   OpenMPDirectiveKind CaptureRegion, SourceLocation StartLoc,
                   SourceLocation LParenLoc, SourceLocation ModifierLoc,
                   SourceLocation EndLoc)
-      : OMPClause(OMPC_device, StartLoc, EndLoc), OMPClauseWithPreInit(this),
-        LParenLoc(LParenLoc), Modifier(Modifier), ModifierLoc(ModifierLoc),
-        Device(E) {
+      : OMPClause(llvm::omp::OMPC_device, StartLoc, EndLoc),
+        OMPClauseWithPreInit(this), LParenLoc(LParenLoc), Modifier(Modifier),
+        ModifierLoc(ModifierLoc), Device(E) {
     setPreInitStmt(HelperE, CaptureRegion);
   }
 
   /// Build an empty clause.
   OMPDeviceClause()
-      : OMPClause(OMPC_device, SourceLocation(), SourceLocation()),
+      : OMPClause(llvm::omp::OMPC_device, SourceLocation(), SourceLocation()),
         OMPClauseWithPreInit(this) {}
 
   /// Sets the location of '('.
   void setLParenLoc(SourceLocation Loc) { LParenLoc = Loc; }
 
   /// Returns the location of '('.
   SourceLocation getLParenLoc() const { return LParenLoc; }
 
public:
   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() == OMPC_device;
+    return T->getClauseKind() == llvm::omp::OMPC_device;
   }
 };
 
 /// This represents 'threads' clause in the '#pragma omp ...' directive.
 ///
 /// \code
 /// #pragma omp ordered threads
 /// \endcode
 /// In this example directive '#pragma omp ordered' has simple 'threads' clause.
 class OMPThreadsClause : public OMPClause {
 public:
   /// Build 'threads' clause.
   ///
   /// \param StartLoc Starting location of the clause.
   /// \param EndLoc Ending location of the clause.
   OMPThreadsClause(SourceLocation StartLoc, SourceLocation EndLoc)
-      : OMPClause(OMPC_threads, StartLoc, EndLoc) {}
+      : OMPClause(llvm::omp::OMPC_threads, StartLoc, EndLoc) {}
 
   /// Build an empty clause.
   OMPThreadsClause()
-      : OMPClause(OMPC_threads, SourceLocation(), SourceLocation()) {}
+      : OMPClause(llvm::omp::OMPC_threads, 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() == OMPC_threads;
+    return T->getClauseKind() == llvm::omp::OMPC_threads;
   }
 };
 
 /// This represents 'simd' clause in the '#pragma omp ...' directive.
 ///
 /// \code
 /// #pragma omp ordered simd
 /// \endcode
 /// In this example directive '#pragma omp ordered' has simple 'simd' clause.
 class OMPSIMDClause : public OMPClause {
 public:
   /// Build 'simd' clause.
   ///
   /// \param StartLoc Starting location of the clause.
   /// \param EndLoc Ending location of the clause.
   OMPSIMDClause(SourceLocation StartLoc, SourceLocation EndLoc)
-      : OMPClause(OMPC_simd, StartLoc, EndLoc) {}
+      : OMPClause(llvm::omp::OMPC_simd, StartLoc, EndLoc) {}
 
   /// Build an empty clause.
-  OMPSIMDClause() : OMPClause(OMPC_simd, SourceLocation(), SourceLocation()) {}
+  OMPSIMDClause()
+      : OMPClause(llvm::omp::OMPC_simd, 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() == OMPC_simd;
+    return T->getClauseKind() == llvm::omp::OMPC_simd;
   }
 };
 
 /// Struct that defines common infrastructure to handle mappable
 /// expressions used in OpenMP clauses.
 class OMPClauseMappableExprCommon {
 public:
   /// Class that represents a component of a mappable expression. E.g.
private:
   /// NumComponents: total number of expression components in the clause.
   explicit OMPMapClause(ArrayRef<OpenMPMapModifierKind> MapModifiers,
                         ArrayRef<SourceLocation> MapModifiersLoc,
                         NestedNameSpecifierLoc MapperQualifierLoc,
                         DeclarationNameInfo MapperIdInfo,
                         OpenMPMapClauseKind MapType, bool MapTypeIsImplicit,
                         SourceLocation MapLoc, const OMPVarListLocTy &Locs,
                         const OMPMappableExprListSizeTy &Sizes)
-      : OMPMappableExprListClause(OMPC_map, Locs, Sizes, &MapperQualifierLoc,
-                                  &MapperIdInfo),
+      : OMPMappableExprListClause(llvm::omp::OMPC_map, Locs, Sizes,
+                                  &MapperQualifierLoc, &MapperIdInfo),
         MapType(MapType), MapTypeIsImplicit(MapTypeIsImplicit), MapLoc(MapLoc) {
     assert(llvm::array_lengthof(MapTypeModifiers) == MapModifiers.size() &&
            "Unexpected number of map type modifiers.");
     llvm::copy(MapModifiers, std::begin(MapTypeModifiers));
 
     assert(llvm::array_lengthof(MapTypeModifiersLoc) ==
                MapModifiersLoc.size() &&
            "Unexpected number of map type modifier locations.");
     llvm::copy(MapModifiersLoc, std::begin(MapTypeModifiersLoc));
   }
 
   /// Build an empty clause.
   ///
   /// \param Sizes All required sizes to build a mappable clause. It includes 1)
   /// NumVars: number of expressions listed in this clause; 2)
   /// NumUniqueDeclarations: number of unique base declarations in this clause;
   /// 3) NumComponentLists: number of component lists in this clause; and 4)
   /// NumComponents: total number of expression components in the clause.
   explicit OMPMapClause(const OMPMappableExprListSizeTy &Sizes)
-      : OMPMappableExprListClause(OMPC_map, OMPVarListLocTy(), Sizes) {}
+      : OMPMappableExprListClause(llvm::omp::OMPC_map, OMPVarListLocTy(),
+                                  Sizes) {}
 
   /// Set map-type-modifier for the clause.
   ///
   /// \param I index for map-type-modifier.
   /// \param T map-type-modifier for the clause.
   void setMapTypeModifier(unsigned I, OpenMPMapModifierKind T) {
     assert(I < NumberOfModifiers &&
            "Unexpected index to store map type modifier, exceeds array size.");
public:
   }
   const_child_range used_children() const {
     auto Children = const_cast<OMPMapClause *>(this)->used_children();
     return const_child_range(Children.begin(), Children.end());
   }
 
 
   static bool classof(const OMPClause *T) {
-    return T->getClauseKind() == OMPC_map;
+    return T->getClauseKind() == llvm::omp::OMPC_map;
   }
 };
 
 /// This represents 'num_teams' clause in the '#pragma omp ...'
 /// directive.
 ///
 /// \code
 /// #pragma omp teams num_teams(n)
public:
   /// \param CaptureRegion Innermost OpenMP region where expressions in this
   /// clause must be captured.
   /// \param StartLoc Starting location of the clause.
   /// \param LParenLoc Location of '('.
   /// \param EndLoc Ending location of the clause.
   OMPNumTeamsClause(Expr *E, Stmt *HelperE, OpenMPDirectiveKind CaptureRegion,
                     SourceLocation StartLoc, SourceLocation LParenLoc,
                     SourceLocation EndLoc)
-      : OMPClause(OMPC_num_teams, StartLoc, EndLoc), OMPClauseWithPreInit(this),
-        LParenLoc(LParenLoc), NumTeams(E) {
+      : OMPClause(llvm::omp::OMPC_num_teams, StartLoc, EndLoc),
+        OMPClauseWithPreInit(this), LParenLoc(LParenLoc), NumTeams(E) {
     setPreInitStmt(HelperE, CaptureRegion);
   }
 
   /// Build an empty clause.
   OMPNumTeamsClause()
-      : OMPClause(OMPC_num_teams, SourceLocation(), SourceLocation()),
+      : OMPClause(llvm::omp::OMPC_num_teams, SourceLocation(),
+                  SourceLocation()),
         OMPClauseWithPreInit(this) {}
 
   /// Sets the location of '('.
   void setLParenLoc(SourceLocation Loc) { LParenLoc = Loc; }
 
   /// Returns the location of '('.
   SourceLocation getLParenLoc() const { return LParenLoc; }
 
public:
   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() == OMPC_num_teams;
+    return T->getClauseKind() == llvm::omp::OMPC_num_teams;
   }
 };
 
 /// This represents 'thread_limit' clause in the '#pragma omp ...'
 /// directive.
 ///
 /// \code
 /// #pragma omp teams thread_limit(n)
public:
   /// clause must be captured.
   /// \param StartLoc Starting location of the clause.
   /// \param LParenLoc Location of '('.
   /// \param EndLoc Ending location of the clause.
   OMPThreadLimitClause(Expr *E, Stmt *HelperE,
                        OpenMPDirectiveKind CaptureRegion,
                        SourceLocation StartLoc, SourceLocation LParenLoc,
                        SourceLocation EndLoc)
-      : OMPClause(OMPC_thread_limit, StartLoc, EndLoc),
+      : OMPClause(llvm::omp::OMPC_thread_limit, StartLoc, EndLoc),
         OMPClauseWithPreInit(this), LParenLoc(LParenLoc), ThreadLimit(E) {
     setPreInitStmt(HelperE, CaptureRegion);
   }
 
   /// Build an empty clause.
   OMPThreadLimitClause()
-      : OMPClause(OMPC_thread_limit, SourceLocation(), SourceLocation()),
+      : OMPClause(llvm::omp::OMPC_thread_limit, SourceLocation(),
+                  SourceLocation()),
         OMPClauseWithPreInit(this) {}
 
   /// Sets the location of '('.
   void setLParenLoc(SourceLocation Loc) { LParenLoc = Loc; }
 
   /// Returns the location of '('.
   SourceLocation getLParenLoc() const { return LParenLoc; }
 
public:
   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() == OMPC_thread_limit;
+    return T->getClauseKind() == llvm::omp::OMPC_thread_limit;
   }
 };
 
 /// This represents 'priority' clause in the '#pragma omp ...'
 /// directive.
 ///
 /// \code
 /// #pragma omp task priority(n)
public:
   /// \param CaptureRegion Innermost OpenMP region where expressions in this
   /// clause must be captured.
   /// \param StartLoc Starting location of the clause.
   /// \param LParenLoc Location of '('.
   /// \param EndLoc Ending location of the clause.
   OMPPriorityClause(Expr *Priority, Stmt *HelperPriority,
                     OpenMPDirectiveKind CaptureRegion, SourceLocation StartLoc,
                     SourceLocation LParenLoc, SourceLocation EndLoc)
-      : OMPClause(OMPC_priority, StartLoc, EndLoc), OMPClauseWithPreInit(this),
-        LParenLoc(LParenLoc), Priority(Priority) {
+      : OMPClause(llvm::omp::OMPC_priority, StartLoc, EndLoc),
+        OMPClauseWithPreInit(this), LParenLoc(LParenLoc), Priority(Priority) {
     setPreInitStmt(HelperPriority, CaptureRegion);
   }
 
   /// Build an empty clause.
   OMPPriorityClause()
-      : OMPClause(OMPC_priority, SourceLocation(), SourceLocation()),
+      : OMPClause(llvm::omp::OMPC_priority, SourceLocation(), SourceLocation()),
         OMPClauseWithPreInit(this) {}
 
   /// Sets the location of '('.
   void setLParenLoc(SourceLocation Loc) { LParenLoc = Loc; }
 
   /// Returns the location of '('.
   SourceLocation getLParenLoc() const { return LParenLoc; }
 
public:
 
   child_range used_children();
   const_child_range used_children() const {
     auto Children = const_cast<OMPPriorityClause *>(this)->used_children();
     return const_child_range(Children.begin(), Children.end());
   }
 
   static bool classof(const OMPClause *T) {
-    return T->getClauseKind() == OMPC_priority;
+    return T->getClauseKind() == llvm::omp::OMPC_priority;
   }
 };
 
 /// This represents 'grainsize' clause in the '#pragma omp ...'
 /// directive.
 ///
 /// \code
 /// #pragma omp taskloop grainsize(4)
public:
   /// \param HelperSize Helper grainsize for the construct.
   /// \param CaptureRegion Innermost OpenMP region where expressions in this
   /// clause must be captured.
   /// \param StartLoc Starting location of the clause.
   /// \param EndLoc Ending location of the clause.
   OMPGrainsizeClause(Expr *Size, Stmt *HelperSize,
                      OpenMPDirectiveKind CaptureRegion, SourceLocation StartLoc,
                      SourceLocation LParenLoc, SourceLocation EndLoc)
-      : OMPClause(OMPC_grainsize, StartLoc, EndLoc), OMPClauseWithPreInit(this),
-        LParenLoc(LParenLoc), Grainsize(Size) {
+      : OMPClause(llvm::omp::OMPC_grainsize, StartLoc, EndLoc),
+        OMPClauseWithPreInit(this), LParenLoc(LParenLoc), Grainsize(Size) {
     setPreInitStmt(HelperSize, CaptureRegion);
   }
 
   /// Build an empty clause.
   explicit OMPGrainsizeClause()
-      : OMPClause(OMPC_grainsize, SourceLocation(), SourceLocation()),
+      : OMPClause(llvm::omp::OMPC_grainsize, SourceLocation(),
+                  SourceLocation()),
         OMPClauseWithPreInit(this) {}
 
   /// Sets the location of '('.
   void setLParenLoc(SourceLocation Loc) { LParenLoc = Loc; }
 
   /// Returns the location of '('.
   SourceLocation getLParenLoc() const { return LParenLoc; }
 
   /// Return safe iteration space distance.
   Expr *getGrainsize() const { return cast_or_null<Expr>(Grainsize); }
 
   child_range children() { return child_range(&Grainsize, &Grainsize + 1); }
 
   const_child_range children() const {
     return const_child_range(&Grainsize, &Grainsize + 1);
   }
 
   child_range used_children();
   const_child_range used_children() const {
     auto Children = const_cast<OMPGrainsizeClause *>(this)->used_children();
     return const_child_range(Children.begin(), Children.end());
   }
 
   static bool classof(const OMPClause *T) {
-    return T->getClauseKind() == OMPC_grainsize;
+    return T->getClauseKind() == llvm::omp::OMPC_grainsize;
   }
 };
 
 /// This represents 'nogroup' clause in the '#pragma omp ...' directive.
 ///
 /// \code
 /// #pragma omp taskloop nogroup
 /// \endcode
 /// In this example directive '#pragma omp taskloop' has 'nogroup' clause.
 class OMPNogroupClause : public OMPClause {
 public:
   /// Build 'nogroup' clause.
   ///
   /// \param StartLoc Starting location of the clause.
   /// \param EndLoc Ending location of the clause.
   OMPNogroupClause(SourceLocation StartLoc, SourceLocation EndLoc)
-      : OMPClause(OMPC_nogroup, StartLoc, EndLoc) {}
+      : OMPClause(llvm::omp::OMPC_nogroup, StartLoc, EndLoc) {}
 
   /// Build an empty clause.
   OMPNogroupClause()
-      : OMPClause(OMPC_nogroup, SourceLocation(), SourceLocation()) {}
+      : OMPClause(llvm::omp::OMPC_nogroup, 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() == OMPC_nogroup;
+    return T->getClauseKind() == llvm::omp::OMPC_nogroup;
   }
 };
 
 /// This represents 'num_tasks' clause in the '#pragma omp ...'
 /// directive.
 ///
 /// \code
 /// #pragma omp taskloop num_tasks(4)
public:
   /// \param HelperSize Helper grainsize for the construct.
   /// \param CaptureRegion Innermost OpenMP region where expressions in this
   /// clause must be captured.
   /// \param StartLoc Starting location of the clause.
   /// \param EndLoc Ending location of the clause.
   OMPNumTasksClause(Expr *Size, Stmt *HelperSize,
                     OpenMPDirectiveKind CaptureRegion, SourceLocation StartLoc,
                     SourceLocation LParenLoc, SourceLocation EndLoc)
-      : OMPClause(OMPC_num_tasks, StartLoc, EndLoc), OMPClauseWithPreInit(this),
-        LParenLoc(LParenLoc), NumTasks(Size) {
+      : OMPClause(llvm::omp::OMPC_num_tasks, StartLoc, EndLoc),
+        OMPClauseWithPreInit(this), LParenLoc(LParenLoc), NumTasks(Size) {
     setPreInitStmt(HelperSize, CaptureRegion);
   }
 
   /// Build an empty clause.
   explicit OMPNumTasksClause()
-      : OMPClause(OMPC_num_tasks, SourceLocation(), SourceLocation()),
+      : OMPClause(llvm::omp::OMPC_num_tasks, SourceLocation(),
+                  SourceLocation()),
         OMPClauseWithPreInit(this) {}
 
   /// Sets the location of '('.
   void setLParenLoc(SourceLocation Loc) { LParenLoc = Loc; }
 
   /// Returns the location of '('.
   SourceLocation getLParenLoc() const { return LParenLoc; }
 
   /// Return safe iteration space distance.
   Expr *getNumTasks() const { return cast_or_null<Expr>(NumTasks); }
 
   child_range children() { return child_range(&NumTasks, &NumTasks + 1); }
 
   const_child_range children() const {
     return const_child_range(&NumTasks, &NumTasks + 1);
   }
 
   child_range used_children();
   const_child_range used_children() const {
     auto Children = const_cast<OMPNumTasksClause *>(this)->used_children();
     return const_child_range(Children.begin(), Children.end());
   }
 
   static bool classof(const OMPClause *T) {
-    return T->getClauseKind() == OMPC_num_tasks;
+    return T->getClauseKind() == llvm::omp::OMPC_num_tasks;
   }
 };
 
 /// This represents 'hint' clause in the '#pragma omp ...' directive.
 ///
 /// \code
 /// #pragma omp critical (name) hint(6)
 /// \endcode
public:
   /// Build 'hint' clause with expression \a Hint.
   ///
   /// \param Hint Hint expression.
   /// \param StartLoc Starting location of the clause.
   /// \param LParenLoc Location of '('.
   /// \param EndLoc Ending location of the clause.
   OMPHintClause(Expr *Hint, SourceLocation StartLoc, SourceLocation LParenLoc,
                 SourceLocation EndLoc)
-      : OMPClause(OMPC_hint, StartLoc, EndLoc), LParenLoc(LParenLoc),
+      : OMPClause(llvm::omp::OMPC_hint, StartLoc, EndLoc), LParenLoc(LParenLoc),
         Hint(Hint) {}
 
   /// Build an empty clause.
-  OMPHintClause() : OMPClause(OMPC_hint, SourceLocation(), SourceLocation()) {}
+  OMPHintClause()
+      : OMPClause(llvm::omp::OMPC_hint, SourceLocation(), SourceLocation()) {}
 
   /// Sets the location of '('.
   void setLParenLoc(SourceLocation Loc) { LParenLoc = Loc; }
 
   /// Returns the location of '('.
   SourceLocation getLParenLoc() const { return LParenLoc; }
 
   /// Returns number of threads.
   Expr *getHint() const { return cast_or_null<Expr>(Hint); }
 
   child_range children() { return child_range(&Hint, &Hint + 1); }
 
   const_child_range children() const {
     return const_child_range(&Hint, &Hint + 1);
   }
 
   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() == OMPC_hint;
+    return T->getClauseKind() == llvm::omp::OMPC_hint;
   }
 };
 
 /// This represents 'dist_schedule' clause in the '#pragma omp ...'
 /// directive.
 ///
 /// \code
 /// #pragma omp distribute dist_schedule(static, 3)
public:
   /// \param Kind DistSchedule kind.
   /// \param ChunkSize Chunk size.
   /// \param HelperChunkSize Helper chunk size for combined directives.
   OMPDistScheduleClause(SourceLocation StartLoc, SourceLocation LParenLoc,
                         SourceLocation KLoc, SourceLocation CommaLoc,
                         SourceLocation EndLoc,
                         OpenMPDistScheduleClauseKind Kind, Expr *ChunkSize,
                         Stmt *HelperChunkSize)
-      : OMPClause(OMPC_dist_schedule, StartLoc, EndLoc),
+      : OMPClause(llvm::omp::OMPC_dist_schedule, StartLoc, EndLoc),
         OMPClauseWithPreInit(this), LParenLoc(LParenLoc), Kind(Kind),
         KindLoc(KLoc), CommaLoc(CommaLoc), ChunkSize(ChunkSize) {
     setPreInitStmt(HelperChunkSize);
   }
 
   /// Build an empty clause.
   explicit OMPDistScheduleClause()
-      : OMPClause(OMPC_dist_schedule, SourceLocation(), SourceLocation()),
+      : OMPClause(llvm::omp::OMPC_dist_schedule, SourceLocation(),
+                  SourceLocation()),
         OMPClauseWithPreInit(this) {}
 
   /// Get kind of the clause.
   OpenMPDistScheduleClauseKind getDistScheduleKind() const { return Kind; }
 
   /// Get location of '('.
   SourceLocation getLParenLoc() { return LParenLoc; }
 
public:
   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() == OMPC_dist_schedule;
+    return T->getClauseKind() == llvm::omp::OMPC_dist_schedule;
   }
 };
 
 /// This represents 'defaultmap' clause in the '#pragma omp ...' directive.
 ///
 /// \code
 /// #pragma omp target defaultmap(tofrom: scalar)
 /// \endcode
public:
   /// \param EndLoc Ending location of the clause.
   /// \param Kind Defaultmap kind.
   /// \param M The modifier applied to 'defaultmap' clause.
   /// \param MLoc Location of the modifier
   OMPDefaultmapClause(SourceLocation StartLoc, SourceLocation LParenLoc,
                       SourceLocation MLoc, SourceLocation KLoc,
                       SourceLocation EndLoc, OpenMPDefaultmapClauseKind Kind,
                       OpenMPDefaultmapClauseModifier M)
-      : OMPClause(OMPC_defaultmap, StartLoc, EndLoc), LParenLoc(LParenLoc),
-        Modifier(M), ModifierLoc(MLoc), Kind(Kind), KindLoc(KLoc) {}
+      : OMPClause(llvm::omp::OMPC_defaultmap, StartLoc, EndLoc),
+        LParenLoc(LParenLoc), Modifier(M), ModifierLoc(MLoc), Kind(Kind),
+        KindLoc(KLoc) {}
 
   /// Build an empty clause.
   explicit OMPDefaultmapClause()
-      : OMPClause(OMPC_defaultmap, SourceLocation(), SourceLocation()) {}
+      : OMPClause(llvm::omp::OMPC_defaultmap, SourceLocation(),
+                  SourceLocation()) {}
 
   /// Get kind of the clause.
   OpenMPDefaultmapClauseKind getDefaultmapKind() const { return Kind; }
 
   /// Get the modifier of the clause.
   OpenMPDefaultmapClauseModifier getDefaultmapModifier() const {
     return Modifier;
   }
public:
   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() == OMPC_defaultmap;
+    return T->getClauseKind() == llvm::omp::OMPC_defaultmap;
   }
 };
 
 /// This represents clause 'to' in the '#pragma omp ...'
 /// directives.
 ///
 /// \code
 /// #pragma omp target update to(a,b)
class OMPToClause final : public OMPMappableExprListClause<OMPToClause>,
   /// NumVars: number of expressions listed in this clause; 2)
   /// NumUniqueDeclarations: number of unique base declarations in this clause;
   /// 3) NumComponentLists: number of component lists in this clause; and 4)
   /// NumComponents: total number of expression components in the clause.
   explicit OMPToClause(NestedNameSpecifierLoc MapperQualifierLoc,
                        DeclarationNameInfo MapperIdInfo,
                        const OMPVarListLocTy &Locs,
                        const OMPMappableExprListSizeTy &Sizes)
-      : OMPMappableExprListClause(OMPC_to, Locs, Sizes, &MapperQualifierLoc,
-                                  &MapperIdInfo) {}
+      : OMPMappableExprListClause(llvm::omp::OMPC_to, Locs, Sizes,
+                                  &MapperQualifierLoc, &MapperIdInfo) {}
 
   /// Build an empty clause.
   ///
   /// \param Sizes All required sizes to build a mappable clause. It includes 1)
   /// NumVars: number of expressions listed in this clause; 2)
   /// NumUniqueDeclarations: number of unique base declarations in this clause;
   /// 3) NumComponentLists: number of component lists in this clause; and 4)
   /// NumComponents: total number of expression components in the clause.
   explicit OMPToClause(const OMPMappableExprListSizeTy &Sizes)
-      : OMPMappableExprListClause(OMPC_to, OMPVarListLocTy(), Sizes) {}
+      : OMPMappableExprListClause(llvm::omp::OMPC_to, OMPVarListLocTy(),
+                                  Sizes) {}
 
   /// Define the sizes of each trailing object array except the last one. This
   /// is required for TrailingObjects to work properly.
   size_t numTrailingObjects(OverloadToken<Expr *>) const {
     // There are varlist_size() of expressions, and varlist_size() of
     // user-defined mappers.
     return 2 * varlist_size();
   }
public:
   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() == OMPC_to;
+    return T->getClauseKind() == llvm::omp::OMPC_to;
   }
 };
 
 /// This represents clause 'from' in the '#pragma omp ...'
 /// directives.
 ///
 /// \code
 /// #pragma omp target update from(a,b)
class OMPFromClause final
   /// NumVars: number of expressions listed in this clause; 2)
   /// NumUniqueDeclarations: number of unique base declarations in this clause;
   /// 3) NumComponentLists: number of component lists in this clause; and 4)
   /// NumComponents: total number of expression components in the clause.
   explicit OMPFromClause(NestedNameSpecifierLoc MapperQualifierLoc,
                          DeclarationNameInfo MapperIdInfo,
                          const OMPVarListLocTy &Locs,
                          const OMPMappableExprListSizeTy &Sizes)
-      : OMPMappableExprListClause(OMPC_from, Locs, Sizes, &MapperQualifierLoc,
-                                  &MapperIdInfo) {}
+      : OMPMappableExprListClause(llvm::omp::OMPC_from, Locs, Sizes,
+                                  &MapperQualifierLoc, &MapperIdInfo) {}
 
   /// Build an empty clause.
   ///
   /// \param Sizes All required sizes to build a mappable clause. It includes 1)
   /// NumVars: number of expressions listed in this clause; 2)
   /// NumUniqueDeclarations: number of unique base declarations in this clause;
   /// 3) NumComponentLists: number of component lists in this clause; and 4)
   /// NumComponents: total number of expression components in the clause.
   explicit OMPFromClause(const OMPMappableExprListSizeTy &Sizes)
-      : OMPMappableExprListClause(OMPC_from, OMPVarListLocTy(), Sizes) {}
+      : OMPMappableExprListClause(llvm::omp::OMPC_from, OMPVarListLocTy(),
+                                  Sizes) {}
 
   /// Define the sizes of each trailing object array except the last one. This
   /// is required for TrailingObjects to work properly.
   size_t numTrailingObjects(OverloadToken<Expr *>) const {
     // There are varlist_size() of expressions, and varlist_size() of
     // user-defined mappers.
     return 2 * varlist_size();
   }
public:
   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() == OMPC_from;
+    return T->getClauseKind() == llvm::omp::OMPC_from;
   }
 };
 
 /// This represents clause 'use_device_ptr' in the '#pragma omp ...'
 /// directives.
 ///
 /// \code
 /// #pragma omp target data use_device_ptr(a,b)
class OMPUseDevicePtrClause final
   /// LParenLoc: location of '('; 3) EndLoc: ending location of the clause.
   /// \param Sizes All required sizes to build a mappable clause. It includes 1)
   /// NumVars: number of expressions listed in this clause; 2)
   /// NumUniqueDeclarations: number of unique base declarations in this clause;
   /// 3) NumComponentLists: number of component lists in this clause; and 4)
   /// NumComponents: total number of expression components in the clause.
   explicit OMPUseDevicePtrClause(const OMPVarListLocTy &Locs,
                                  const OMPMappableExprListSizeTy &Sizes)
-      : OMPMappableExprListClause(OMPC_use_device_ptr, Locs, Sizes) {}
+      : OMPMappableExprListClause(llvm::omp::OMPC_use_device_ptr, Locs, Sizes) {
+  }
 
   /// Build an empty clause.
   ///
   /// \param Sizes All required sizes to build a mappable clause. It includes 1)
   /// NumVars: number of expressions listed in this clause; 2)
   /// NumUniqueDeclarations: number of unique base declarations in this clause;
   /// 3) NumComponentLists: number of component lists in this clause; and 4)
   /// NumComponents: total number of expression components in the clause.
   explicit OMPUseDevicePtrClause(const OMPMappableExprListSizeTy &Sizes)
-      : OMPMappableExprListClause(OMPC_use_device_ptr, OMPVarListLocTy(),
-                                  Sizes) {}
+      : OMPMappableExprListClause(llvm::omp::OMPC_use_device_ptr,
+                                  OMPVarListLocTy(), Sizes) {}
 
   /// Define the sizes of each trailing object array except the last one. This
   /// is required for TrailingObjects to work properly.
   size_t numTrailingObjects(OverloadToken<Expr *>) const {
     return 3 * varlist_size();
   }
   size_t numTrailingObjects(OverloadToken<ValueDecl *>) const {
     return getUniqueDeclarationsNum();
public:
   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() == OMPC_use_device_ptr;
+    return T->getClauseKind() == llvm::omp::OMPC_use_device_ptr;
   }
 };
 
 /// This represents clause 'is_device_ptr' in the '#pragma omp ...'
 /// directives.
 ///
 /// \code
 /// #pragma omp target is_device_ptr(a,b)
class OMPIsDevicePtrClause final
   /// LParenLoc: location of '('; 3) EndLoc: ending location of the clause.
   /// \param Sizes All required sizes to build a mappable clause. It includes 1)
   /// NumVars: number of expressions listed in this clause; 2)
   /// NumUniqueDeclarations: number of unique base declarations in this clause;
   /// 3) NumComponentLists: number of component lists in this clause; and 4)
   /// NumComponents: total number of expression components in the clause.
   explicit OMPIsDevicePtrClause(const OMPVarListLocTy &Locs,
                                 const OMPMappableExprListSizeTy &Sizes)
-      : OMPMappableExprListClause(OMPC_is_device_ptr, Locs, Sizes) {}
+      : OMPMappableExprListClause(llvm::omp::OMPC_is_device_ptr, Locs, Sizes) {}
 
   /// Build an empty clause.
   ///
   /// \param Sizes All required sizes to build a mappable clause. It includes 1)
   /// NumVars: number of expressions listed in this clause; 2)
   /// NumUniqueDeclarations: number of unique base declarations in this clause;
   /// 3) NumComponentLists: number of component lists in this clause; and 4)
   /// NumComponents: total number of expression components in the clause.
   explicit OMPIsDevicePtrClause(const OMPMappableExprListSizeTy &Sizes)
-      : OMPMappableExprListClause(OMPC_is_device_ptr, OMPVarListLocTy(),
-                                  Sizes) {}
+      : OMPMappableExprListClause(llvm::omp::OMPC_is_device_ptr,
+                                  OMPVarListLocTy(), Sizes) {}
 
   /// Define the sizes of each trailing object array except the last one. This
   /// is required for TrailingObjects to work properly.
   size_t numTrailingObjects(OverloadToken<Expr *>) const {
     return varlist_size();
   }
   size_t numTrailingObjects(OverloadToken<ValueDecl *>) const {
     return getUniqueDeclarationsNum();
public:
   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() == OMPC_is_device_ptr;
+    return T->getClauseKind() == llvm::omp::OMPC_is_device_ptr;
   }
 };
 
 /// This represents clause 'nontemporal' in the '#pragma omp ...' directives.
 ///
 /// \code
 /// #pragma omp simd nontemporal(a)
 /// \endcode
class OMPNontemporalClause final
   /// Build clause with number of variables \a N.
   ///
   /// \param StartLoc Starting location of the clause.
   /// \param LParenLoc Location of '('.
   /// \param EndLoc Ending location of the clause.
   /// \param N Number of the variables in the clause.
   OMPNontemporalClause(SourceLocation StartLoc, SourceLocation LParenLoc,
                        SourceLocation EndLoc, unsigned N)
-      : OMPVarListClause<OMPNontemporalClause>(OMPC_nontemporal, StartLoc,
-                                               LParenLoc, EndLoc, N) {}
+      : OMPVarListClause<OMPNontemporalClause>(llvm::omp::OMPC_nontemporal,
+                                               StartLoc, LParenLoc, EndLoc, N) {
+  }
 
   /// Build an empty clause.
   ///
   /// \param N Number of variables.
   explicit OMPNontemporalClause(unsigned N)
       : OMPVarListClause<OMPNontemporalClause>(
-            OMPC_nontemporal, SourceLocation(), SourceLocation(),
+            llvm::omp::OMPC_nontemporal, SourceLocation(), SourceLocation(),
             SourceLocation(), N) {}
 
   /// Get the list of privatied copies if the member expression was captured by
   /// one of the privatization clauses.
   MutableArrayRef<Expr *> getPrivateRefs() {
     return MutableArrayRef<Expr *>(varlist_end(), varlist_size());
   }
   ArrayRef<const Expr *> getPrivateRefs() const {
public:
   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() == OMPC_nontemporal;
+    return T->getClauseKind() == llvm::omp::OMPC_nontemporal;
   }
 };
 
 /// This represents 'order' clause in the '#pragma omp ...' directive.
 ///
 /// \code
 /// #pragma omp simd order(concurrent)
 /// \endcode
public:
   /// \param A Argument of the clause ('concurrent').
   /// \param ALoc Starting location of the argument.
   /// \param StartLoc Starting location of the clause.
   /// \param LParenLoc Location of '('.
   /// \param EndLoc Ending location of the clause.
   OMPOrderClause(OpenMPOrderClauseKind A, SourceLocation ALoc,
                  SourceLocation StartLoc, SourceLocation LParenLoc,
                  SourceLocation EndLoc)
-      : OMPClause(OMPC_order, StartLoc, EndLoc), LParenLoc(LParenLoc), Kind(A),
-        KindKwLoc(ALoc) {}
+      : OMPClause(llvm::omp::OMPC_order, StartLoc, EndLoc),
+        LParenLoc(LParenLoc), Kind(A), KindKwLoc(ALoc) {}
 
   /// Build an empty clause.
   OMPOrderClause()
-      : OMPClause(OMPC_order, SourceLocation(), SourceLocation()) {}
+      : OMPClause(llvm::omp::OMPC_order, SourceLocation(), SourceLocation()) {}
 
   /// Sets the location of '('.
   void setLParenLoc(SourceLocation Loc) { LParenLoc = Loc; }
 
   /// Returns the location of '('.
   SourceLocation getLParenLoc() const { return LParenLoc; }
 
   /// Returns kind of the clause.
public:
   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() == OMPC_order;
+    return T->getClauseKind() == llvm::omp::OMPC_order;
   }
 };
 
 /// This represents 'destroy' clause in the '#pragma omp depobj'
 /// directive.
 ///
 /// \code
 /// #pragma omp depobj(a) destroy
 /// \endcode
 /// In this example directive '#pragma omp depobj' has 'destroy' clause.
 class OMPDestroyClause final : public OMPClause {
 public:
   /// Build 'destroy' clause.
   ///
   /// \param StartLoc Starting location of the clause.
   /// \param EndLoc Ending location of the clause.
   OMPDestroyClause(SourceLocation StartLoc, SourceLocation EndLoc)
-      : OMPClause(OMPC_destroy, StartLoc, EndLoc) {}
+      : OMPClause(llvm::omp::OMPC_destroy, StartLoc, EndLoc) {}
 
   /// Build an empty clause.
   OMPDestroyClause()
-      : OMPClause(OMPC_destroy, SourceLocation(), SourceLocation()) {}
+      : OMPClause(llvm::omp::OMPC_destroy, 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() == OMPC_destroy;
+    return T->getClauseKind() == llvm::omp::OMPC_destroy;
   }
 };
 
 /// This represents 'detach' clause in the '#pragma omp task' directive.
 ///
 /// \code
 /// #pragma omp task detach(evt)
 /// \endcode
public:
   /// Build 'detach' clause with event-handler \a Evt.
   ///
   /// \param Evt Event handler expression.
   /// \param StartLoc Starting location of the clause.
   /// \param LParenLoc Location of '('.
   /// \param EndLoc Ending location of the clause.
   OMPDetachClause(Expr *Evt, SourceLocation StartLoc, SourceLocation LParenLoc,
                   SourceLocation EndLoc)
-      : OMPClause(OMPC_detach, StartLoc, EndLoc), LParenLoc(LParenLoc),
-        Evt(Evt) {}
+      : OMPClause(llvm::omp::OMPC_detach, StartLoc, EndLoc),
+        LParenLoc(LParenLoc), Evt(Evt) {}
 
   /// Build an empty clause.
   OMPDetachClause()
-      : OMPClause(OMPC_detach, SourceLocation(), SourceLocation()) {}
+      : OMPClause(llvm::omp::OMPC_detach, SourceLocation(), SourceLocation()) {}
 
   /// Returns the location of '('.
   SourceLocation getLParenLoc() const { return LParenLoc; }
 
   /// Returns event-handler expression.
   Expr *getEventHandler() const { return cast_or_null<Expr>(Evt); }
 
   child_range children() { return child_range(&Evt, &Evt + 1); }
 
   const_child_range children() const {
     return const_child_range(&Evt, &Evt + 1);
   }
 
   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() == OMPC_detach;
+    return T->getClauseKind() == llvm::omp::OMPC_detach;
   }
 };
 
 /// This represents clause 'inclusive' in the '#pragma omp scan' directive.
 ///
 /// \code
 /// #pragma omp scan inclusive(a,b)
 /// \endcode
class OMPInclusiveClause final
   /// Build clause with number of variables \a N.
   ///
   /// \param StartLoc Starting location of the clause.
   /// \param LParenLoc Location of '('.
   /// \param EndLoc Ending location of the clause.
   /// \param N Number of the variables in the clause.
   OMPInclusiveClause(SourceLocation StartLoc, SourceLocation LParenLoc,
                      SourceLocation EndLoc, unsigned N)
-      : OMPVarListClause<OMPInclusiveClause>(OMPC_inclusive, StartLoc,
-                                             LParenLoc, EndLoc, N) {}
+      : OMPVarListClause<OMPInclusiveClause>(llvm::omp::OMPC_inclusive,
+                                             StartLoc, LParenLoc, EndLoc, N) {}
 
   /// Build an empty clause.
   ///
   /// \param N Number of variables.
   explicit OMPInclusiveClause(unsigned N)
-      : OMPVarListClause<OMPInclusiveClause>(OMPC_inclusive, SourceLocation(),
+      : OMPVarListClause<OMPInclusiveClause>(llvm::omp::OMPC_inclusive,
                                              SourceLocation(), SourceLocation(),
-                                             N) {}
+                                             SourceLocation(), N) {}
 
 public:
   /// Creates clause with a list of variables \a VL.
   ///
   /// \param C AST context.
   /// \param StartLoc Starting location of the clause.
   /// \param LParenLoc Location of '('.
   /// \param EndLoc Ending location of the clause.
public:
   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() == OMPC_inclusive;
+    return T->getClauseKind() == llvm::omp::OMPC_inclusive;
   }
 };
 
 /// This represents clause 'exclusive' in the '#pragma omp scan' directive.
 ///
 /// \code
 /// #pragma omp scan exclusive(a,b)
 /// \endcode
class OMPExclusiveClause final
   /// Build clause with number of variables \a N.
   ///
   /// \param StartLoc Starting location of the clause.
   /// \param LParenLoc Location of '('.
   /// \param EndLoc Ending location of the clause.
   /// \param N Number of the variables in the clause.
   OMPExclusiveClause(SourceLocation StartLoc, SourceLocation LParenLoc,
                      SourceLocation EndLoc, unsigned N)
-      : OMPVarListClause<OMPExclusiveClause>(OMPC_exclusive, StartLoc,
-                                             LParenLoc, EndLoc, N) {}
+      : OMPVarListClause<OMPExclusiveClause>(llvm::omp::OMPC_exclusive,
+                                             StartLoc, LParenLoc, EndLoc, N) {}
 
   /// Build an empty clause.
   ///
   /// \param N Number of variables.
   explicit OMPExclusiveClause(unsigned N)
-      : OMPVarListClause<OMPExclusiveClause>(OMPC_exclusive, SourceLocation(),
+      : OMPVarListClause<OMPExclusiveClause>(llvm::omp::OMPC_exclusive,
                                              SourceLocation(), SourceLocation(),
-                                             N) {}
+                                             SourceLocation(), N) {}
 
 public:
   /// Creates clause with a list of variables \a VL.
   ///
   /// \param C AST context.
   /// \param StartLoc Starting location of the clause.
   /// \param LParenLoc Location of '('.
   /// \param EndLoc Ending location of the clause.
public:
   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() == OMPC_exclusive;
+    return T->getClauseKind() == llvm::omp::OMPC_exclusive;
   }
 };
 
 /// This class implements a simple visitor for OMPClause
 /// subclasses.
 template<class ImplClass, template <typename> class Ptr, typename RetTy>
 class OMPClauseVisitorBase {
 public:
 #define PTR(CLASS) Ptr<CLASS>
 #define DISPATCH(CLASS) \
   return static_cast<ImplClass*>(this)->Visit##CLASS(static_cast<PTR(CLASS)>(S))
 
-#define OPENMP_CLAUSE(Name, Class)                              \
+#define OMP_CLAUSE_CLASS(Enum, Str, Class) \
   RetTy Visit ## Class (PTR(Class) S) { DISPATCH(Class); }
-#include "clang/Basic/OpenMPKinds.def"
+#include "llvm/Frontend/OpenMP/OMPKinds.def"
 
   RetTy Visit(PTR(OMPClause) S) {
     // Top switch clause: visit each OMPClause.
     switch (S->getClauseKind()) {
-    default: llvm_unreachable("Unknown clause kind!");
-#define OPENMP_CLAUSE(Name, Class)                              \
-    case OMPC_ ## Name : return Visit ## Class(static_cast<PTR(Class)>(S));
-#include "clang/Basic/OpenMPKinds.def"
+#define OMP_CLAUSE_CLASS(Enum, Str, Class)                                     \
+  case llvm::omp::Clause::Enum:                                                \
+    return Visit##Class(static_cast<PTR(Class)>(S));
+#define OMP_CLAUSE_NO_CLASS(Enum, Str)                                         \
+  case llvm::omp::Clause::Enum:                                                \
+    break;
+#include "llvm/Frontend/OpenMP/OMPKinds.def"
     }
   }
   // Base case, ignore it. :)
   RetTy VisitOMPClause(PTR(OMPClause) Node) { return RetTy(); }
 #undef PTR
 #undef DISPATCH
 };
 
class OMPClausePrinter final : public OMPClauseVisitor<OMPClausePrinter> {
 
   /// Process clauses with list of variables.
   template <typename T> void VisitOMPClauseList(T *Node, char StartSym);
 
 public:
   OMPClausePrinter(raw_ostream &OS, const PrintingPolicy &Policy)
       : OS(OS), Policy(Policy) {}
 
-#define OPENMP_CLAUSE(Name, Class) void Visit##Class(Class *S);
-#include "clang/Basic/OpenMPKinds.def"
+#define OMP_CLAUSE_CLASS(Enum, Str, Class)                                     \
+  void Visit##Class(Class *S);
+#include "llvm/Frontend/OpenMP/OMPKinds.def"
 };
 
 /// Helper data structure representing the traits in a match clause of an
 /// `declare variant` or `metadirective`. The outer level is an ordered
 /// collection of selector sets, each with an associated kind and an ordered
 /// collection of selectors. A selector has a kind, an optional score/condition,
 /// and an ordered collection of properties.
 class OMPTraitInfo {

clang/include/clang/AST/RecursiveASTVisitor.h

#undef DEF_TRAVERSE_TMPL_INST
   bool TraverseCXXRecordHelper(CXXRecordDecl *D);
   bool TraverseDeclaratorHelper(DeclaratorDecl *D);
   bool TraverseDeclContextHelper(DeclContext *DC);
   bool TraverseFunctionHelper(FunctionDecl *D);
   bool TraverseVarHelper(VarDecl *D);
   bool TraverseOMPExecutableDirective(OMPExecutableDirective *S);
   bool TraverseOMPLoopDirective(OMPLoopDirective *S);
   bool TraverseOMPClause(OMPClause *C);
-#define OPENMP_CLAUSE(Name, Class) bool Visit##Class(Class *C);
-#include "clang/Basic/OpenMPKinds.def"
+#define OMP_CLAUSE_CLASS(Enum, Str, Class) bool Visit##Class(Class *C);
+#include "llvm/Frontend/OpenMP/OMPKinds.def"
   /// Process clauses with list of variables.
   template <typename T> bool VisitOMPClauseList(T *Node);
   /// Process clauses with pre-initis.
   bool VisitOMPClauseWithPreInit(OMPClauseWithPreInit *Node);
   bool VisitOMPClauseWithPostUpdate(OMPClauseWithPostUpdate *Node);
 
   bool dataTraverseNode(Stmt *S, DataRecursionQueue *Queue);
   bool PostVisitStmt(Stmt *S);
DEF_TRAVERSE_STMT(OMPTargetTeamsDistributeSimdDirective,
                   { TRY_TO(TraverseOMPExecutableDirective(S)); })
 
 // OpenMP clauses.
 template <typename Derived>
 bool RecursiveASTVisitor<Derived>::TraverseOMPClause(OMPClause *C) {
   if (!C)
     return true;
   switch (C->getClauseKind()) {
-#define OPENMP_CLAUSE(Name, Class)                                             \
-  case OMPC_##Name:                                                            \
+#define OMP_CLAUSE_CLASS(Enum, Str, Class)                                     \
+  case llvm::omp::Clause::Enum:                                                \
     TRY_TO(Visit##Class(static_cast<Class *>(C)));                             \
     break;
-#include "clang/Basic/OpenMPKinds.def"
-  case OMPC_threadprivate:
-  case OMPC_uniform:
-  case OMPC_device_type:
-  case OMPC_match:
-  case OMPC_unknown:
+#define OMP_CLAUSE_NO_CLASS(Enum, Str)                                         \
+  case llvm::omp::Clause::Enum:                                                \
     break;
+#include "llvm/Frontend/OpenMP/OMPKinds.def"
   }
   return true;
 }
 
 template <typename Derived>
 bool RecursiveASTVisitor<Derived>::VisitOMPClauseWithPreInit(
     OMPClauseWithPreInit *Node) {
   TRY_TO(TraverseStmt(Node->getPreInitStmt()));

clang/include/clang/Basic/Attr.td

def OMPCaptureNoInit : InheritableAttr {
   let SemaHandler = 0;
   let Documentation = [Undocumented];
 }
 
 def OMPCaptureKind : Attr {
   // This attribute has no spellings as it is only ever created implicitly.
   let Spellings = [];
   let SemaHandler = 0;
-  let Args = [UnsignedArgument<"CaptureKind">];
+  let Args = [UnsignedArgument<"CaptureKindVal">];
   let Documentation = [Undocumented];
+  let AdditionalMembers = [{
+    llvm::omp::Clause getCaptureKind() const {
+      return static_cast<llvm::omp::Clause>(getCaptureKindVal());
+    }
+  }];
 }
 
 def OMPReferencedVar : Attr {
   // This attribute has no spellings as it is only ever created implicitly.
   let Spellings = [];
   let SemaHandler = 0;
   let Args = [ExprArgument<"Ref">];
   let Documentation = [Undocumented];

clang/include/clang/Basic/OpenMPKinds.h

 #include "llvm/Frontend/OpenMP/OMPConstants.h"
 
 namespace clang {
 
 /// OpenMP directives.
 using OpenMPDirectiveKind = llvm::omp::Directive;
 
 /// OpenMP clauses.
-enum OpenMPClauseKind {
-#define OPENMP_CLAUSE(Name, Class) \
-  OMPC_##Name,
-#include "clang/Basic/OpenMPKinds.def"
-  OMPC_threadprivate,
-  OMPC_uniform,
-  OMPC_device_type,
-  OMPC_match,
-  OMPC_unknown
-};
+using OpenMPClauseKind = llvm::omp::Clause;
 
 /// OpenMP attributes for 'schedule' clause.
 enum OpenMPScheduleClauseKind {
 #define OPENMP_SCHEDULE_KIND(Name) \
   OMPC_SCHEDULE_##Name,
 #include "clang/Basic/OpenMPKinds.def"
   OMPC_SCHEDULE_unknown
 };

 
 /// OpenMP modifiers for 'reduction' clause.
 enum OpenMPReductionClauseModifier {
 #define OPENMP_REDUCTION_MODIFIER(Name) OMPC_REDUCTION_##Name,
 #include "clang/Basic/OpenMPKinds.def"
   OMPC_REDUCTION_unknown,
 };
 
-OpenMPClauseKind getOpenMPClauseKind(llvm::StringRef Str);
-const char *getOpenMPClauseName(OpenMPClauseKind Kind);
-
 unsigned getOpenMPSimpleClauseType(OpenMPClauseKind Kind, llvm::StringRef Str);
 const char *getOpenMPSimpleClauseTypeName(OpenMPClauseKind Kind, unsigned Type);
 
 bool isAllowedClauseForDirective(OpenMPDirectiveKind DKind,
                                  OpenMPClauseKind CKind,
                                  unsigned OpenMPVersion);
 
 /// Checks if the specified directive is a directive with an associated

clang/include/clang/Basic/OpenMPKinds.def

 #endif
 #ifndef OPENMP_SCAN_CLAUSE
 #define OPENMP_SCAN_CLAUSE(Name)
 #endif
 #ifndef OPENMP_REDUCTION_MODIFIER
 #define OPENMP_REDUCTION_MODIFIER(Name)
 #endif
 
-// OpenMP clauses.
-OPENMP_CLAUSE(allocator, OMPAllocatorClause)
-OPENMP_CLAUSE(if, OMPIfClause)
-OPENMP_CLAUSE(final, OMPFinalClause)
-OPENMP_CLAUSE(num_threads, OMPNumThreadsClause)
-OPENMP_CLAUSE(safelen, OMPSafelenClause)
-OPENMP_CLAUSE(simdlen, OMPSimdlenClause)
-OPENMP_CLAUSE(collapse, OMPCollapseClause)
-OPENMP_CLAUSE(default, OMPDefaultClause)
-OPENMP_CLAUSE(private, OMPPrivateClause)
-OPENMP_CLAUSE(firstprivate, OMPFirstprivateClause)
-OPENMP_CLAUSE(lastprivate, OMPLastprivateClause)
-OPENMP_CLAUSE(shared,  OMPSharedClause)
-OPENMP_CLAUSE(reduction,  OMPReductionClause)
-OPENMP_CLAUSE(linear,  OMPLinearClause)
-OPENMP_CLAUSE(aligned, OMPAlignedClause)
-OPENMP_CLAUSE(copyin,  OMPCopyinClause)
-OPENMP_CLAUSE(copyprivate,  OMPCopyprivateClause)
-OPENMP_CLAUSE(proc_bind, OMPProcBindClause)
-OPENMP_CLAUSE(schedule, OMPScheduleClause)
-OPENMP_CLAUSE(ordered, OMPOrderedClause)
-OPENMP_CLAUSE(nowait, OMPNowaitClause)
-OPENMP_CLAUSE(untied, OMPUntiedClause)
-OPENMP_CLAUSE(mergeable, OMPMergeableClause)
-OPENMP_CLAUSE(flush, OMPFlushClause)
-OPENMP_CLAUSE(read, OMPReadClause)
-OPENMP_CLAUSE(write, OMPWriteClause)
-OPENMP_CLAUSE(update, OMPUpdateClause)
-OPENMP_CLAUSE(capture, OMPCaptureClause)
-OPENMP_CLAUSE(seq_cst, OMPSeqCstClause)
-OPENMP_CLAUSE(acq_rel, OMPAcqRelClause)
-OPENMP_CLAUSE(acquire, OMPAcquireClause)
-OPENMP_CLAUSE(release, OMPReleaseClause)
-OPENMP_CLAUSE(relaxed, OMPRelaxedClause)
-OPENMP_CLAUSE(depend, OMPDependClause)
-OPENMP_CLAUSE(device, OMPDeviceClause)
-OPENMP_CLAUSE(threads, OMPThreadsClause)
-OPENMP_CLAUSE(simd, OMPSIMDClause)
-OPENMP_CLAUSE(map, OMPMapClause)
-OPENMP_CLAUSE(num_teams, OMPNumTeamsClause)
-OPENMP_CLAUSE(thread_limit, OMPThreadLimitClause)
-OPENMP_CLAUSE(priority, OMPPriorityClause)
-OPENMP_CLAUSE(grainsize, OMPGrainsizeClause)
-OPENMP_CLAUSE(nogroup, OMPNogroupClause)
-OPENMP_CLAUSE(num_tasks, OMPNumTasksClause)
-OPENMP_CLAUSE(hint, OMPHintClause)
-OPENMP_CLAUSE(dist_schedule, OMPDistScheduleClause)
-OPENMP_CLAUSE(defaultmap, OMPDefaultmapClause)
-OPENMP_CLAUSE(to, OMPToClause)
-OPENMP_CLAUSE(from, OMPFromClause)
-OPENMP_CLAUSE(use_device_ptr, OMPUseDevicePtrClause)
-OPENMP_CLAUSE(is_device_ptr, OMPIsDevicePtrClause)
-OPENMP_CLAUSE(task_reduction,  OMPTaskReductionClause)
-OPENMP_CLAUSE(in_reduction,  OMPInReductionClause)
-OPENMP_CLAUSE(unified_address, OMPUnifiedAddressClause)
-OPENMP_CLAUSE(unified_shared_memory, OMPUnifiedSharedMemoryClause)
-OPENMP_CLAUSE(reverse_offload, OMPReverseOffloadClause)
-OPENMP_CLAUSE(dynamic_allocators, OMPDynamicAllocatorsClause)
-OPENMP_CLAUSE(atomic_default_mem_order, OMPAtomicDefaultMemOrderClause)
-OPENMP_CLAUSE(allocate, OMPAllocateClause)
-OPENMP_CLAUSE(nontemporal, OMPNontemporalClause)
-OPENMP_CLAUSE(order, OMPOrderClause)
-OPENMP_CLAUSE(depobj, OMPDepobjClause)
-OPENMP_CLAUSE(destroy, OMPDestroyClause)
-OPENMP_CLAUSE(detach, OMPDetachClause)
-OPENMP_CLAUSE(inclusive, OMPInclusiveClause)
-OPENMP_CLAUSE(exclusive, OMPExclusiveClause)
-
 // Clauses allowed for OpenMP directive 'scan'.
 OPENMP_SCAN_CLAUSE(inclusive)
 OPENMP_SCAN_CLAUSE(exclusive)
 
 // Clauses allowed for OpenMP directive 'parallel'.
 OPENMP_PARALLEL_CLAUSE(if)
 OPENMP_PARALLEL_CLAUSE(num_threads)
 OPENMP_PARALLEL_CLAUSE(default)

clang/lib/AST/ASTTypeTraits.cpp

 #include "clang/AST/DeclNodes.inc"
   { NKI_None, "Stmt" },
 #define STMT(DERIVED, BASE) { NKI_##BASE, #DERIVED },
 #include "clang/AST/StmtNodes.inc"
   { NKI_None, "Type" },
 #define TYPE(DERIVED, BASE) { NKI_##BASE, #DERIVED "Type" },
 #include "clang/AST/TypeNodes.inc"
   { NKI_None, "OMPClause" },
-#define OPENMP_CLAUSE(TextualSpelling, Class) {NKI_OMPClause, #Class},
-#include "clang/Basic/OpenMPKinds.def"
+#define OMP_CLAUSE_CLASS(Enum, Str, Class) {NKI_OMPClause, #Class},
+#include "llvm/Frontend/OpenMP/OMPKinds.def"
 };
 
 bool ASTNodeKind::isBaseOf(ASTNodeKind Other, unsigned *Distance) const {
   return isBaseOf(KindId, Other.KindId, Distance);
 }
 
 bool ASTNodeKind::isBaseOf(NodeKindId Base, NodeKindId Derived,
                            unsigned *Distance) {

 #define ABSTRACT_TYPE(Class, Base)
 #include "clang/AST/TypeNodes.inc"
   }
   llvm_unreachable("invalid type kind");
  }
 
 ASTNodeKind ASTNodeKind::getFromNode(const OMPClause &C) {
   switch (C.getClauseKind()) {
-#define OPENMP_CLAUSE(Name, Class)                                             \
-    case OMPC_##Name: return ASTNodeKind(NKI_##Class);
-#include "clang/Basic/OpenMPKinds.def"
-  case OMPC_threadprivate:
-  case OMPC_uniform:
-  case OMPC_device_type:
-  case OMPC_match:
-  case OMPC_unknown:
+#define OMP_CLAUSE_CLASS(Enum, Str, Class)                                     \
+  case llvm::omp::Clause::Enum:                                                \
+    return ASTNodeKind(NKI_##Class);
+#define OMP_CLAUSE_NO_CLASS(Enum, Str)                                         \
+  case llvm::omp::Clause::Enum:                                                \
     llvm_unreachable("unexpected OpenMP clause kind");
+#include "llvm/Frontend/OpenMP/OMPKinds.def"
   }
   llvm_unreachable("invalid stmt kind");
 }
 
 void DynTypedNode::print(llvm::raw_ostream &OS,
                          const PrintingPolicy &PP) const {
   if (const TemplateArgument *TA = get<TemplateArgument>())
     TA->print(PP, OS);

clang/lib/AST/AttrImpl.cpp

for (auto *E : aligneds()) {
     OS << ")";
     ++NI;
   }
   steps_iterator I = steps_begin();
   modifiers_iterator MI = modifiers_begin();
   for (auto *E : linears()) {
     OS << " linear(";
     if (*MI != OMPC_LINEAR_unknown)
-      OS << getOpenMPSimpleClauseTypeName(OMPC_linear, *MI) << "(";
+      OS << getOpenMPSimpleClauseTypeName(llvm::omp::Clause::OMPC_linear, *MI)
+         << "(";
     E->printPretty(OS, nullptr, Policy);
     if (*MI != OMPC_LINEAR_unknown)
       OS << ")";
     if (*I) {
       OS << ": ";
       (*I)->printPretty(OS, nullptr, Policy);
     }
     OS << ")";

clang/lib/AST/OpenMPClause.cpp

 using namespace clang;
 using namespace llvm;
 using namespace omp;
 
 OMPClause::child_range OMPClause::children() {
   switch (getClauseKind()) {
   default:
     break;
-#define OPENMP_CLAUSE(Name, Class)                                             \
-  case OMPC_##Name:                                                            \
+#define OMP_CLAUSE_CLASS(Enum, Str, Class)                                           \
+  case Enum:                                                                   \
     return static_cast<Class *>(this)->children();
-#include "clang/Basic/OpenMPKinds.def"
+#include "llvm/Frontend/OpenMP/OMPKinds.def"
   }
   llvm_unreachable("unknown OMPClause");
 }
 
 OMPClause::child_range OMPClause::used_children() {
   switch (getClauseKind()) {
-#define OPENMP_CLAUSE(Name, Class)                                             \
-  case OMPC_##Name:                                                            \
+#define OMP_CLAUSE_CLASS(Enum, Str, Class)                                           \
+  case Enum:                                                                   \
     return static_cast<Class *>(this)->used_children();
-#include "clang/Basic/OpenMPKinds.def"
+#include "llvm/Frontend/OpenMP/OMPKinds.def"
   case OMPC_threadprivate:
   case OMPC_uniform:
   case OMPC_device_type:
   case OMPC_match:
   case OMPC_unknown:
     break;
   }
   llvm_unreachable("unknown OMPClause");

clang/lib/AST/StmtProfile.cpp

 class OMPClauseProfiler : public ConstOMPClauseVisitor<OMPClauseProfiler> {
   StmtProfiler *Profiler;
   /// Process clauses with list of variables.
   template <typename T>
   void VisitOMPClauseList(T *Node);
 
 public:
   OMPClauseProfiler(StmtProfiler *P) : Profiler(P) { }
-#define OPENMP_CLAUSE(Name, Class)                                             \
-  void Visit##Class(const Class *C);
-#include "clang/Basic/OpenMPKinds.def"
+#define OMP_CLAUSE_CLASS(Enum, Str, Class) void Visit##Class(const Class *C);
+#include "llvm/Frontend/OpenMP/OMPKinds.def"
   void VistOMPClauseWithPreInit(const OMPClauseWithPreInit *C);
   void VistOMPClauseWithPostUpdate(const OMPClauseWithPostUpdate *C);
 };
 
 void OMPClauseProfiler::VistOMPClauseWithPreInit(
     const OMPClauseWithPreInit *C) {
   if (auto *S = C->getPreInitStmt())
     Profiler->VisitStmt(S);

clang/lib/AST/TextNodeDumper.cpp

 void TextNodeDumper::Visit(const OMPClause *C) {
   if (!C) {
     ColorScope Color(OS, ShowColors, NullColor);
     OS << "<<<NULL>>> OMPClause";
     return;
   }
   {
     ColorScope Color(OS, ShowColors, AttrColor);
-    StringRef ClauseName(getOpenMPClauseName(C->getClauseKind()));
+    StringRef ClauseName(llvm::omp::getOpenMPClauseName(C->getClauseKind()));
     OS << "OMP" << ClauseName.substr(/*Start=*/0, /*N=*/1).upper()
        << ClauseName.drop_front() << "Clause";
   }
   dumpPointer(C);
   dumpSourceRange(SourceRange(C->getBeginLoc(), C->getEndLoc()));
   if (C->isImplicit())
     OS << " <implicit>";
 }
for (const auto *C : D->clauselists()) {
     AddChild([=] {
       if (!C) {
         ColorScope Color(OS, ShowColors, NullColor);
         OS << "<<<NULL>>> OMPClause";
         return;
       }
       {
         ColorScope Color(OS, ShowColors, AttrColor);
-        StringRef ClauseName(getOpenMPClauseName(C->getClauseKind()));
+        StringRef ClauseName(
+            llvm::omp::getOpenMPClauseName(C->getClauseKind()));
         OS << "OMP" << ClauseName.substr(/*Start=*/0, /*N=*/1).upper()
            << ClauseName.drop_front() << "Clause";
       }
       dumpPointer(C);
       dumpSourceRange(SourceRange(C->getBeginLoc(), C->getEndLoc()));
     });
   }
 }

clang/lib/ASTMatchers/CMakeLists.txt

 add_subdirectory(Dynamic)
 
-set(LLVM_LINK_COMPONENTS support)
+set(LLVM_LINK_COMPONENTS
+  FrontendOpenMP
+  Support
+)
 
 add_clang_library(clangASTMatchers
   ASTMatchFinder.cpp
   ASTMatchersInternal.cpp
   GtestMatchers.cpp
 
   LINK_LIBS
   clangAST
   clangBasic
   clangLex
   )

clang/lib/ASTMatchers/Dynamic/Marshallers.h

static ArgKind getKind() {
     return ArgKind(ArgKind::AK_String);
   }
 };
 
 template <> struct ArgTypeTraits<OpenMPClauseKind> {
 private:
   static Optional<OpenMPClauseKind> getClauseKind(llvm::StringRef ClauseKind) {
     return llvm::StringSwitch<Optional<OpenMPClauseKind>>(ClauseKind)
-#define OPENMP_CLAUSE(TextualSpelling, Class)                                  \
-  .Case("OMPC_" #TextualSpelling, OMPC_##TextualSpelling)
-#include "clang/Basic/OpenMPKinds.def"
+#define OMP_CLAUSE_CLASS(Enum, Str, Class) .Case(#Enum, llvm::omp::Clause::Enum)
+#include "llvm/Frontend/OpenMP/OMPKinds.def"
         .Default(llvm::None);
   }
 
 public:
   static bool is(const VariantValue &Value) {
     return Value.isString() && getClauseKind(Value.getString());
   }
 

clang/lib/Analysis/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
+  FrontendOpenMP
   Support
   )
 
 add_clang_library(clangAnalysis
   AnalysisDeclContext.cpp
   BodyFarm.cpp
   CFG.cpp
   CFGReachabilityAnalysis.cpp

clang/lib/Basic/OpenMPKinds.cpp

 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/Support/ErrorHandling.h"
 #include <cassert>
 
 using namespace clang;
 using namespace llvm::omp;
 
-OpenMPClauseKind clang::getOpenMPClauseKind(StringRef Str) {
-  // 'flush' clause cannot be specified explicitly, because this is an implicit
-  // clause for 'flush' directive. If the 'flush' clause is explicitly specified
-  // the Parser should generate a warning about extra tokens at the end of the
-  // directive.
-  // 'depobj' clause cannot be specified explicitly, because this is an implicit
-  // clause for 'depobj' directive. If the 'depobj' clause is explicitly
-  // specified the Parser should generate a warning about extra tokens at the
-  // end of the directive.
-  if (llvm::StringSwitch<bool>(Str)
-          .Case("flush", true)
-          .Case("depobj", true)
-          .Default(false))
-    return OMPC_unknown;
-  return llvm::StringSwitch<OpenMPClauseKind>(Str)
-#define OPENMP_CLAUSE(Name, Class) .Case(#Name, OMPC_##Name)
-#include "clang/Basic/OpenMPKinds.def"
-      .Case("uniform", OMPC_uniform)
-      .Case("device_type", OMPC_device_type)
-      .Case("match", OMPC_match)
-      .Default(OMPC_unknown);
-}
-
-const char *clang::getOpenMPClauseName(OpenMPClauseKind Kind) {
-  assert(Kind <= OMPC_unknown);
-  switch (Kind) {
-  case OMPC_unknown:
-    return "unknown";
-#define OPENMP_CLAUSE(Name, Class)                                             \
-  case OMPC_##Name:                                                            \
-    return #Name;
-#include "clang/Basic/OpenMPKinds.def"
-  case OMPC_uniform:
-    return "uniform";
-  case OMPC_threadprivate:
-    return "threadprivate or thread local";
-  case OMPC_device_type:
-    return "device_type";
-  case OMPC_match:
-    return "match";
-  }
-  llvm_unreachable("Invalid OpenMP clause kind");
-}
-
 unsigned clang::getOpenMPSimpleClauseType(OpenMPClauseKind Kind,
                                           StringRef Str) {
   switch (Kind) {
   case OMPC_default:
     return llvm::StringSwitch<unsigned>(Str)
 #define OMP_DEFAULT_KIND(Enum, Name) .Case(Name, unsigned(Enum))
 #include "llvm/Frontend/OpenMP/OMPKinds.def"
         .Default(unsigned(llvm::omp::OMP_DEFAULT_unknown));

clang/lib/CodeGen/CGOpenMPRuntimeNVPTX.cpp

if (auto *CSI = CGF.CapturedStmtInfo) {
         // value in the outer region.
         if (!IsForCombinedParallelRegion) {
           if (!FD->hasAttrs())
             return;
           const auto *Attr = FD->getAttr<OMPCaptureKindAttr>();
           if (!Attr)
             return;
           if (((Attr->getCaptureKind() != OMPC_map) &&
-               !isOpenMPPrivate(
-                   static_cast<OpenMPClauseKind>(Attr->getCaptureKind()))) ||
+               !isOpenMPPrivate(Attr->getCaptureKind())) ||
               ((Attr->getCaptureKind() == OMPC_map) &&
                !FD->getType()->isAnyPointerType()))
             return;
         }
         if (!FD->getType()->isReferenceType()) {
           assert(!VD->getType()->isVariablyModifiedType() &&
                  "Parameter captured by value with variably modified type");
           EscapedParameters.insert(VD);

clang/lib/Parse/ParseOpenMP.cpp

if (CKind != OMPC_match) {
     // Skip the last annot_pragma_openmp_end.
     (void)ConsumeAnnotationToken();
     return true;
   }
   (void)ConsumeToken();
   // Parse '('.
   BalancedDelimiterTracker T(*this, tok::l_paren, tok::annot_pragma_openmp_end);
   if (T.expectAndConsume(diag::err_expected_lparen_after,
-                         getOpenMPClauseName(OMPC_match))) {
+                         getOpenMPClauseName(OMPC_match).data())) {
     while (!SkipUntil(tok::annot_pragma_openmp_end, StopBeforeMatch))
       ;
     // Skip the last annot_pragma_openmp_end.
     (void)ConsumeAnnotationToken();
     return true;
   }
 
   // Parse inner context selectors.

 static Optional<SimpleClauseData>
 parseOpenMPSimpleClause(Parser &P, OpenMPClauseKind Kind) {
   const Token &Tok = P.getCurToken();
   SourceLocation Loc = Tok.getLocation();
   SourceLocation LOpen = P.ConsumeToken();
   // Parse '('.
   BalancedDelimiterTracker T(P, tok::l_paren, tok::annot_pragma_openmp_end);
   if (T.expectAndConsume(diag::err_expected_lparen_after,
-                         getOpenMPClauseName(Kind)))
+                         getOpenMPClauseName(Kind).data()))
     return llvm::None;
 
   unsigned Type = getOpenMPSimpleClauseType(
       Kind, Tok.isAnnotation() ? "" : P.getPreprocessor().getSpelling(Tok));
   SourceLocation TypeLoc = Tok.getLocation();
   if (Tok.isNot(tok::r_paren) && Tok.isNot(tok::comma) &&
       Tok.isNot(tok::annot_pragma_openmp_end))
     P.ConsumeAnyToken();
Parser::DeclGroupPtrTy Parser::ParseOpenMPDeclarativeDirectiveWithExtDecl(
   case OMPD_allocate: {
     ConsumeToken();
     DeclDirectiveListParserHelper Helper(this, DKind);
     if (!ParseOpenMPSimpleVarList(DKind, Helper,
                                   /*AllowScopeSpecifier=*/true)) {
       SmallVector<OMPClause *, 1> Clauses;
       if (Tok.isNot(tok::annot_pragma_openmp_end)) {
         SmallVector<llvm::PointerIntPair<OMPClause *, 1, bool>,
-                    OMPC_unknown + 1>
-            FirstClauses(OMPC_unknown + 1);
+                    unsigned(OMPC_unknown) + 1>
+          FirstClauses(unsigned(OMPC_unknown) + 1);
         while (Tok.isNot(tok::annot_pragma_openmp_end)) {
           OpenMPClauseKind CKind =
               Tok.isAnnotation() ? OMPC_unknown
                                  : getOpenMPClauseKind(PP.getSpelling(Tok));
           Actions.StartOpenMPClause(CKind);
-          OMPClause *Clause = ParseOpenMPClause(OMPD_allocate, CKind,
-                                                !FirstClauses[CKind].getInt());
+          OMPClause *Clause = ParseOpenMPClause(
+              OMPD_allocate, CKind, !FirstClauses[unsigned(CKind)].getInt());
           SkipUntil(tok::comma, tok::identifier, tok::annot_pragma_openmp_end,
                     StopBeforeMatch);
-          FirstClauses[CKind].setInt(true);
+          FirstClauses[unsigned(CKind)].setInt(true);
           if (Clause != nullptr)
             Clauses.push_back(Clause);
           if (Tok.is(tok::annot_pragma_openmp_end)) {
             Actions.EndOpenMPClause();
             break;
           }
           // Skip ',' if any.
           if (Tok.is(tok::comma))
             ConsumeToken();
           Actions.EndOpenMPClause();
         }
         skipUntilPragmaOpenMPEnd(DKind);
       }
       // Skip the last annot_pragma_openmp_end.
       ConsumeAnnotationToken();
       return Actions.ActOnOpenMPAllocateDirective(Loc, Helper.getIdentifiers(),
                                                   Clauses);
     }
     break;
   }
   case OMPD_requires: {
     SourceLocation StartLoc = ConsumeToken();
     SmallVector<OMPClause *, 5> Clauses;
-    SmallVector<llvm::PointerIntPair<OMPClause *, 1, bool>, OMPC_unknown + 1>
-    FirstClauses(OMPC_unknown + 1);
+    SmallVector<llvm::PointerIntPair<OMPClause *, 1, bool>,
+                unsigned(OMPC_unknown) + 1>
+    FirstClauses(unsigned(OMPC_unknown) + 1);
     if (Tok.is(tok::annot_pragma_openmp_end)) {
       Diag(Tok, diag::err_omp_expected_clause)
           << getOpenMPDirectiveName(OMPD_requires);
       break;
     }
     while (Tok.isNot(tok::annot_pragma_openmp_end)) {
       OpenMPClauseKind CKind = Tok.isAnnotation()
                                    ? OMPC_unknown
                                    : getOpenMPClauseKind(PP.getSpelling(Tok));
       Actions.StartOpenMPClause(CKind);
-      OMPClause *Clause = ParseOpenMPClause(OMPD_requires, CKind,
-                                            !FirstClauses[CKind].getInt());
+      OMPClause *Clause = ParseOpenMPClause(
+          OMPD_requires, CKind, !FirstClauses[unsigned(CKind)].getInt());
       SkipUntil(tok::comma, tok::identifier, tok::annot_pragma_openmp_end,
                 StopBeforeMatch);
-      FirstClauses[CKind].setInt(true);
+      FirstClauses[unsigned(CKind)].setInt(true);
       if (Clause != nullptr)
         Clauses.push_back(Clause);
       if (Tok.is(tok::annot_pragma_openmp_end)) {
         Actions.EndOpenMPClause();
         break;
       }
       // Skip ',' if any.
       if (Tok.is(tok::comma))

 ///         annot_pragma_openmp_end
 ///
 StmtResult
 Parser::ParseOpenMPDeclarativeOrExecutableDirective(ParsedStmtContext StmtCtx) {
   assert(Tok.is(tok::annot_pragma_openmp) && "Not an OpenMP directive!");
   ParsingOpenMPDirectiveRAII DirScope(*this);
   ParenBraceBracketBalancer BalancerRAIIObj(*this);
   SmallVector<OMPClause *, 5> Clauses;
-  SmallVector<llvm::PointerIntPair<OMPClause *, 1, bool>, OMPC_unknown + 1>
-  FirstClauses(OMPC_unknown + 1);
+  SmallVector<llvm::PointerIntPair<OMPClause *, 1, bool>,
+              unsigned(OMPC_unknown) + 1>
+  FirstClauses(unsigned(OMPC_unknown) + 1);
   unsigned ScopeFlags = Scope::FnScope | Scope::DeclScope |
                         Scope::CompoundStmtScope | Scope::OpenMPDirectiveScope;
   SourceLocation Loc = ConsumeAnnotationToken(), EndLoc;
   OpenMPDirectiveKind DKind = parseOpenMPDirectiveKind(*this);
   OpenMPDirectiveKind CancelRegion = OMPD_unknown;
   // Name of critical directive.
   DeclarationNameInfo DirName;
   StmtResult Directive = StmtError();
case OMPD_allocate: {
     }
     ConsumeToken();
     DeclDirectiveListParserHelper Helper(this, DKind);
     if (!ParseOpenMPSimpleVarList(DKind, Helper,
                                   /*AllowScopeSpecifier=*/false)) {
       SmallVector<OMPClause *, 1> Clauses;
       if (Tok.isNot(tok::annot_pragma_openmp_end)) {
         SmallVector<llvm::PointerIntPair<OMPClause *, 1, bool>,
-                    OMPC_unknown + 1>
-            FirstClauses(OMPC_unknown + 1);
+                    unsigned(OMPC_unknown) + 1>
+            FirstClauses(unsigned(OMPC_unknown) + 1);
         while (Tok.isNot(tok::annot_pragma_openmp_end)) {
           OpenMPClauseKind CKind =
               Tok.isAnnotation() ? OMPC_unknown
                                  : getOpenMPClauseKind(PP.getSpelling(Tok));
           Actions.StartOpenMPClause(CKind);
-          OMPClause *Clause = ParseOpenMPClause(OMPD_allocate, CKind,
-                                                !FirstClauses[CKind].getInt());
+          OMPClause *Clause = ParseOpenMPClause(
+              OMPD_allocate, CKind, !FirstClauses[unsigned(CKind)].getInt());
           SkipUntil(tok::comma, tok::identifier, tok::annot_pragma_openmp_end,
                     StopBeforeMatch);
-          FirstClauses[CKind].setInt(true);
+          FirstClauses[unsigned(CKind)].setInt(true);
           if (Clause != nullptr)
             Clauses.push_back(Clause);
           if (Tok.is(tok::annot_pragma_openmp_end)) {
             Actions.EndOpenMPClause();
             break;
           }
           // Skip ',' if any.
           if (Tok.is(tok::comma))
while (Tok.isNot(tok::annot_pragma_openmp_end)) {
                  "Expected flush or depobj directives.");
           CKind = OMPC_depobj;
         }
       }
       // No more implicit clauses allowed.
       ImplicitClauseAllowed = false;
       Actions.StartOpenMPClause(CKind);
       HasImplicitClause = false;
-      OMPClause *Clause =
-          ParseOpenMPClause(DKind, CKind, !FirstClauses[CKind].getInt());
-      FirstClauses[CKind].setInt(true);
+      OMPClause *Clause = ParseOpenMPClause(
+          DKind, CKind, !FirstClauses[unsigned(CKind)].getInt());
+      FirstClauses[unsigned(CKind)].setInt(true);
       if (Clause) {
-        FirstClauses[CKind].setPointer(Clause);
+        FirstClauses[unsigned(CKind)].setPointer(Clause);
         Clauses.push_back(Clause);
       }
 
       // Skip ',' if any.
       if (Tok.is(tok::comma))
         ConsumeToken();
       Actions.EndOpenMPClause();
     }
     // End location of the directive.
     EndLoc = Tok.getLocation();
     // Consume final annot_pragma_openmp_end.
     ConsumeAnnotationToken();
 
     // OpenMP [2.13.8, ordered Construct, Syntax]
     // If the depend clause is specified, the ordered construct is a stand-alone
     // directive.
-    if (DKind == OMPD_ordered && FirstClauses[OMPC_depend].getInt()) {
+    if (DKind == OMPD_ordered && FirstClauses[unsigned(OMPC_depend)].getInt()) {
       if ((StmtCtx & ParsedStmtContext::AllowStandaloneOpenMPDirectives) ==
           ParsedStmtContext()) {
         Diag(Loc, diag::err_omp_immediate_directive)
             << getOpenMPDirectiveName(DKind) << 1
             << getOpenMPClauseName(OMPC_depend);
       }
       HasAssociatedStatement = false;
     }

 OMPClause *Parser::ParseOpenMPSingleExprWithArgClause(OpenMPDirectiveKind DKind,
                                                       OpenMPClauseKind Kind,
                                                       bool ParseOnly) {
   SourceLocation Loc = ConsumeToken();
   SourceLocation DelimLoc;
   // Parse '('.
   BalancedDelimiterTracker T(*this, tok::l_paren, tok::annot_pragma_openmp_end);
   if (T.expectAndConsume(diag::err_expected_lparen_after,
-                         getOpenMPClauseName(Kind)))
+                         getOpenMPClauseName(Kind).data()))
     return nullptr;
 
   ExprResult Val;
   SmallVector<unsigned, 4> Arg;
   SmallVector<SourceLocation, 4> KLoc;
   if (Kind == OMPC_schedule) {
     enum { Modifier1, Modifier2, ScheduleKind, NumberOfElements };
     Arg.resize(NumberOfElements);
bool Parser::ParseOpenMPVarList(OpenMPDirectiveKind DKind,
                                 OpenMPVarListDataTy &Data) {
   UnqualifiedId UnqualifiedReductionId;
   bool InvalidReductionId = false;
   bool IsInvalidMapperModifier = false;
 
   // Parse '('.
   BalancedDelimiterTracker T(*this, tok::l_paren, tok::annot_pragma_openmp_end);
   if (T.expectAndConsume(diag::err_expected_lparen_after,
-                         getOpenMPClauseName(Kind)))
+                         getOpenMPClauseName(Kind).data()))
     return true;
 
   bool NeedRParenForLinear = false;
   BalancedDelimiterTracker LinearT(*this, tok::l_paren,
                                   tok::annot_pragma_openmp_end);
   // Handle reduction-identifier for reduction clause.
   if (Kind == OMPC_reduction || Kind == OMPC_task_reduction ||
       Kind == OMPC_in_reduction) {

clang/lib/Sema/SemaOpenMP.cpp

if (DSAStack->hasExplicitDirective(isOpenMPTargetExecutionDirective,
       OMPC = OMPC_map;
       if (DSAStack->mustBeFirstprivateAtLevel(
               NewLevel, getVariableCategoryFromDecl(LangOpts, D)))
         OMPC = OMPC_firstprivate;
       break;
     }
   }
   if (OMPC != OMPC_unknown)
-    FD->addAttr(OMPCaptureKindAttr::CreateImplicit(Context, OMPC));
+    FD->addAttr(OMPCaptureKindAttr::CreateImplicit(Context, unsigned(OMPC)));
 }
 
 bool Sema::isOpenMPTargetCapturedDecl(const ValueDecl *D, unsigned Level,
                                       unsigned CaptureLevel) const {
   assert(LangOpts.OpenMP && "OpenMP is not allowed");
   // Return true if the current level is no longer enclosed in a target region.
 
   SmallVector<OpenMPDirectiveKind, 4> Regions;

clang/lib/Sema/TreeTransform.h

#define VALUESTMT(Node, Parent)                   \
   LLVM_ATTRIBUTE_NOINLINE \
   StmtResult Transform##Node(Node *S, StmtDiscardKind SDK);
 #define EXPR(Node, Parent)                        \
   LLVM_ATTRIBUTE_NOINLINE \
   ExprResult Transform##Node(Node *E);
 #define ABSTRACT_STMT(Stmt)
 #include "clang/AST/StmtNodes.inc"
 
-#define OPENMP_CLAUSE(Name, Class)                        \
+#define OMP_CLAUSE_CLASS(Enum, Str, Class)                                           \
   LLVM_ATTRIBUTE_NOINLINE \
   OMPClause *Transform ## Class(Class *S);
-#include "clang/Basic/OpenMPKinds.def"
+#include "llvm/Frontend/OpenMP/OMPKinds.def"
 
   /// Build a new qualified type given its unqualified type and type location.
   ///
   /// By default, this routine adds type qualifiers only to types that can
   /// have qualifiers, and silently suppresses those qualifiers that are not
   /// permitted. Subclasses may override this routine to provide different
   /// behavior.
   QualType RebuildQualifiedType(QualType T, QualifiedTypeLoc TL);

 template<typename Derived>
 OMPClause *TreeTransform<Derived>::TransformOMPClause(OMPClause *S) {
   if (!S)
     return S;
 
   switch (S->getClauseKind()) {
   default: break;
   // Transform individual clause nodes
-#define OPENMP_CLAUSE(Name, Class)                                             \
-  case OMPC_ ## Name :                                                         \
+#define OMP_CLAUSE_CLASS(Enum, Str, Class) \
+  case Enum:                                                                   \
     return getDerived().Transform ## Class(cast<Class>(S));
-#include "clang/Basic/OpenMPKinds.def"
+#include "llvm/Frontend/OpenMP/OMPKinds.def"
   }
 
   return S;
 }
 
 
 template<typename Derived>
 ExprResult TreeTransform<Derived>::TransformExpr(Expr *E) {

clang/lib/Serialization/ASTReader.cpp

 class OMPClauseReader : public OMPClauseVisitor<OMPClauseReader> {
   ASTRecordReader &Record;
   ASTContext &Context;
 
 public:
   OMPClauseReader(ASTRecordReader &Record)
       : Record(Record), Context(Record.getContext()) {}
 
-#define OPENMP_CLAUSE(Name, Class) void Visit##Class(Class *C);
-#include "clang/Basic/OpenMPKinds.def"
+#define OMP_CLAUSE_CLASS(Enum, Str, Class) void Visit##Class(Class *C);
+#include "llvm/Frontend/OpenMP/OMPKinds.def"
   OMPClause *readClause();
   void VisitOMPClauseWithPreInit(OMPClauseWithPreInit *C);
   void VisitOMPClauseWithPostUpdate(OMPClauseWithPostUpdate *C);
 };
 
 } // end namespace clang
 
 OMPClause *ASTRecordReader::readOMPClause() {
   return OMPClauseReader(*this).readClause();
 }
 
 OMPClause *OMPClauseReader::readClause() {
   OMPClause *C = nullptr;
-  switch (Record.readInt()) {
-  case OMPC_if:
+  switch (llvm::omp::Clause(Record.readInt())) {
+  case llvm::omp::OMPC_if:
     C = new (Context) OMPIfClause();
     break;
-  case OMPC_final:
+  case llvm::omp::OMPC_final:
     C = new (Context) OMPFinalClause();
     break;
-  case OMPC_num_threads:
+  case llvm::omp::OMPC_num_threads:
     C = new (Context) OMPNumThreadsClause();
     break;
-  case OMPC_safelen:
+  case llvm::omp::OMPC_safelen:
     C = new (Context) OMPSafelenClause();
     break;
-  case OMPC_simdlen:
+  case llvm::omp::OMPC_simdlen:
     C = new (Context) OMPSimdlenClause();
     break;
-  case OMPC_allocator:
+  case llvm::omp::OMPC_allocator:
     C = new (Context) OMPAllocatorClause();
     break;
-  case OMPC_collapse:
+  case llvm::omp::OMPC_collapse:
     C = new (Context) OMPCollapseClause();
     break;
-  case OMPC_default:
+  case llvm::omp::OMPC_default:
     C = new (Context) OMPDefaultClause();
     break;
-  case OMPC_proc_bind:
+  case llvm::omp::OMPC_proc_bind:
     C = new (Context) OMPProcBindClause();
     break;
-  case OMPC_schedule:
+  case llvm::omp::OMPC_schedule:
     C = new (Context) OMPScheduleClause();
     break;
-  case OMPC_ordered:
+  case llvm::omp::OMPC_ordered:
     C = OMPOrderedClause::CreateEmpty(Context, Record.readInt());
     break;
-  case OMPC_nowait:
+  case llvm::omp::OMPC_nowait:
     C = new (Context) OMPNowaitClause();
     break;
-  case OMPC_untied:
+  case llvm::omp::OMPC_untied:
     C = new (Context) OMPUntiedClause();
     break;
-  case OMPC_mergeable:
+  case llvm::omp::OMPC_mergeable:
     C = new (Context) OMPMergeableClause();
     break;
-  case OMPC_read:
+  case llvm::omp::OMPC_read:
     C = new (Context) OMPReadClause();
     break;
-  case OMPC_write:
+  case llvm::omp::OMPC_write:
     C = new (Context) OMPWriteClause();
     break;
-  case OMPC_update:
+  case llvm::omp::OMPC_update:
     C = OMPUpdateClause::CreateEmpty(Context, Record.readInt());
     break;
-  case OMPC_capture:
+  case llvm::omp::OMPC_capture:
     C = new (Context) OMPCaptureClause();
     break;
-  case OMPC_seq_cst:
+  case llvm::omp::OMPC_seq_cst:
     C = new (Context) OMPSeqCstClause();
     break;
-  case OMPC_acq_rel:
+  case llvm::omp::OMPC_acq_rel:
     C = new (Context) OMPAcqRelClause();
     break;
-  case OMPC_acquire:
+  case llvm::omp::OMPC_acquire:
     C = new (Context) OMPAcquireClause();
     break;
-  case OMPC_release:
+  case llvm::omp::OMPC_release:
     C = new (Context) OMPReleaseClause();
     break;
-  case OMPC_relaxed:
+  case llvm::omp::OMPC_relaxed:
     C = new (Context) OMPRelaxedClause();
     break;
-  case OMPC_threads:
+  case llvm::omp::OMPC_threads:
     C = new (Context) OMPThreadsClause();
     break;
-  case OMPC_simd:
+  case llvm::omp::OMPC_simd:
     C = new (Context) OMPSIMDClause();
     break;
-  case OMPC_nogroup:
+  case llvm::omp::OMPC_nogroup:
     C = new (Context) OMPNogroupClause();
     break;
-  case OMPC_unified_address:
+  case llvm::omp::OMPC_unified_address:
     C = new (Context) OMPUnifiedAddressClause();
     break;
-  case OMPC_unified_shared_memory:
+  case llvm::omp::OMPC_unified_shared_memory:
     C = new (Context) OMPUnifiedSharedMemoryClause();
     break;
-  case OMPC_reverse_offload:
+  case llvm::omp::OMPC_reverse_offload:
     C = new (Context) OMPReverseOffloadClause();
     break;
-  case OMPC_dynamic_allocators:
+  case llvm::omp::OMPC_dynamic_allocators:
     C = new (Context) OMPDynamicAllocatorsClause();
     break;
-  case OMPC_atomic_default_mem_order:
+  case llvm::omp::OMPC_atomic_default_mem_order:
     C = new (Context) OMPAtomicDefaultMemOrderClause();
     break;
- case OMPC_private:
+ case llvm::omp::OMPC_private:
     C = OMPPrivateClause::CreateEmpty(Context, Record.readInt());
     break;
-  case OMPC_firstprivate:
+  case llvm::omp::OMPC_firstprivate:
     C = OMPFirstprivateClause::CreateEmpty(Context, Record.readInt());
     break;
-  case OMPC_lastprivate:
+  case llvm::omp::OMPC_lastprivate:
     C = OMPLastprivateClause::CreateEmpty(Context, Record.readInt());
     break;
-  case OMPC_shared:
+  case llvm::omp::OMPC_shared:
     C = OMPSharedClause::CreateEmpty(Context, Record.readInt());
     break;
-  case OMPC_reduction:
+  case llvm::omp::OMPC_reduction:
     C = OMPReductionClause::CreateEmpty(Context, Record.readInt());
     break;
-  case OMPC_task_reduction:
+  case llvm::omp::OMPC_task_reduction:
     C = OMPTaskReductionClause::CreateEmpty(Context, Record.readInt());
     break;
-  case OMPC_in_reduction:
+  case llvm::omp::OMPC_in_reduction:
     C = OMPInReductionClause::CreateEmpty(Context, Record.readInt());
     break;
-  case OMPC_linear:
+  case llvm::omp::OMPC_linear:
     C = OMPLinearClause::CreateEmpty(Context, Record.readInt());
     break;
-  case OMPC_aligned:
+  case llvm::omp::OMPC_aligned:
     C = OMPAlignedClause::CreateEmpty(Context, Record.readInt());
     break;
-  case OMPC_copyin:
+  case llvm::omp::OMPC_copyin:
     C = OMPCopyinClause::CreateEmpty(Context, Record.readInt());
     break;
-  case OMPC_copyprivate:
+  case llvm::omp::OMPC_copyprivate:
     C = OMPCopyprivateClause::CreateEmpty(Context, Record.readInt());
     break;
-  case OMPC_flush:
+  case llvm::omp::OMPC_flush:
     C = OMPFlushClause::CreateEmpty(Context, Record.readInt());
     break;
-  case OMPC_depobj:
+  case llvm::omp::OMPC_depobj:
     C = OMPDepobjClause::CreateEmpty(Context);
     break;
-  case OMPC_depend: {
+  case llvm::omp::OMPC_depend: {
     unsigned NumVars = Record.readInt();
     unsigned NumLoops = Record.readInt();
     C = OMPDependClause::CreateEmpty(Context, NumVars, NumLoops);
     break;
   }
-  case OMPC_device:
+  case llvm::omp::OMPC_device:
     C = new (Context) OMPDeviceClause();
     break;
-  case OMPC_map: {
+  case llvm::omp::OMPC_map: {
     OMPMappableExprListSizeTy Sizes;
     Sizes.NumVars = Record.readInt();
     Sizes.NumUniqueDeclarations = Record.readInt();
     Sizes.NumComponentLists = Record.readInt();
     Sizes.NumComponents = Record.readInt();
     C = OMPMapClause::CreateEmpty(Context, Sizes);
     break;
   }
-  case OMPC_num_teams:
+  case llvm::omp::OMPC_num_teams:
     C = new (Context) OMPNumTeamsClause();
     break;
-  case OMPC_thread_limit:
+  case llvm::omp::OMPC_thread_limit:
     C = new (Context) OMPThreadLimitClause();
     break;
-  case OMPC_priority:
+  case llvm::omp::OMPC_priority:
     C = new (Context) OMPPriorityClause();
     break;
-  case OMPC_grainsize:
+  case llvm::omp::OMPC_grainsize:
     C = new (Context) OMPGrainsizeClause();
     break;
-  case OMPC_num_tasks:
+  case llvm::omp::OMPC_num_tasks:
     C = new (Context) OMPNumTasksClause();
     break;
-  case OMPC_hint:
+  case llvm::omp::OMPC_hint:
     C = new (Context) OMPHintClause();
     break;
-  case OMPC_dist_schedule:
+  case llvm::omp::OMPC_dist_schedule:
     C = new (Context) OMPDistScheduleClause();
     break;
-  case OMPC_defaultmap:
+  case llvm::omp::OMPC_defaultmap:
     C = new (Context) OMPDefaultmapClause();
     break;
-  case OMPC_to: {
+  case llvm::omp::OMPC_to: {
     OMPMappableExprListSizeTy Sizes;
     Sizes.NumVars = Record.readInt();
     Sizes.NumUniqueDeclarations = Record.readInt();
     Sizes.NumComponentLists = Record.readInt();
     Sizes.NumComponents = Record.readInt();
     C = OMPToClause::CreateEmpty(Context, Sizes);
     break;
   }
-  case OMPC_from: {
+  case llvm::omp::OMPC_from: {
     OMPMappableExprListSizeTy Sizes;
     Sizes.NumVars = Record.readInt();
     Sizes.NumUniqueDeclarations = Record.readInt();
     Sizes.NumComponentLists = Record.readInt();
     Sizes.NumComponents = Record.readInt();
     C = OMPFromClause::CreateEmpty(Context, Sizes);
     break;
   }
-  case OMPC_use_device_ptr: {
+  case llvm::omp::OMPC_use_device_ptr: {
     OMPMappableExprListSizeTy Sizes;
     Sizes.NumVars = Record.readInt();
     Sizes.NumUniqueDeclarations = Record.readInt();
     Sizes.NumComponentLists = Record.readInt();
     Sizes.NumComponents = Record.readInt();
     C = OMPUseDevicePtrClause::CreateEmpty(Context, Sizes);
     break;
   }
-  case OMPC_is_device_ptr: {
+  case llvm::omp::OMPC_is_device_ptr: {
     OMPMappableExprListSizeTy Sizes;
     Sizes.NumVars = Record.readInt();
     Sizes.NumUniqueDeclarations = Record.readInt();
     Sizes.NumComponentLists = Record.readInt();
     Sizes.NumComponents = Record.readInt();
     C = OMPIsDevicePtrClause::CreateEmpty(Context, Sizes);
     break;
   }
-  case OMPC_allocate:
+  case llvm::omp::OMPC_allocate:
     C = OMPAllocateClause::CreateEmpty(Context, Record.readInt());
     break;
-  case OMPC_nontemporal:
+  case llvm::omp::OMPC_nontemporal:
     C = OMPNontemporalClause::CreateEmpty(Context, Record.readInt());
     break;
-  case OMPC_inclusive:
+  case llvm::omp::OMPC_inclusive:
     C = OMPInclusiveClause::CreateEmpty(Context, Record.readInt());
     break;
-  case OMPC_exclusive:
+  case llvm::omp::OMPC_exclusive:
     C = OMPExclusiveClause::CreateEmpty(Context, Record.readInt());
     break;
-  case OMPC_order:
+  case llvm::omp::OMPC_order:
     C = new (Context) OMPOrderClause();
     break;
-  case OMPC_destroy:
+  case llvm::omp::OMPC_destroy:
     C = new (Context) OMPDestroyClause();
     break;
-  case OMPC_detach:
+  case llvm::omp::OMPC_detach:
     C = new (Context) OMPDetachClause();
     break;
+#define OMP_CLAUSE_NO_CLASS(Enum, Str)                                         \
+  case llvm::omp::Enum:                                                        \
+    break;
+#include "llvm/Frontend/OpenMP/OMPKinds.def"
   }
   assert(C && "Unknown OMPClause type");
 
   Visit(C);
   C->setLocStart(Record.readSourceLocation());
   C->setLocEnd(Record.readSourceLocation());
 
   return C;

clang/lib/Serialization/ASTWriter.cpp

 
 namespace {
 
 class OMPClauseWriter : public OMPClauseVisitor<OMPClauseWriter> {
   ASTRecordWriter &Record;
 
 public:
   OMPClauseWriter(ASTRecordWriter &Record) : Record(Record) {}
-#define OPENMP_CLAUSE(Name, Class) void Visit##Class(Class *S);
-#include "clang/Basic/OpenMPKinds.def"
+#define OMP_CLAUSE_CLASS(Enum, Str, Class) void Visit##Class(Class *S);
+#include "llvm/Frontend/OpenMP/OMPKinds.def"
   void writeClause(OMPClause *C);
   void VisitOMPClauseWithPreInit(OMPClauseWithPreInit *C);
   void VisitOMPClauseWithPostUpdate(OMPClauseWithPostUpdate *C);
 };
 
 }
 
 void ASTRecordWriter::writeOMPClause(OMPClause *C) {
   OMPClauseWriter(*this).writeClause(C);
 }
 
 void OMPClauseWriter::writeClause(OMPClause *C) {
-  Record.push_back(C->getClauseKind());
+  Record.push_back(unsigned(C->getClauseKind()));
   Visit(C);
   Record.AddSourceLocation(C->getBeginLoc());
   Record.AddSourceLocation(C->getEndLoc());
 }
 
 void OMPClauseWriter::VisitOMPClauseWithPreInit(OMPClauseWithPreInit *C) {
   Record.push_back(uint64_t(C->getCaptureRegion()));
   Record.AddStmt(C->getPreInitStmt());

clang/lib/StaticAnalyzer/Checkers/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
+  FrontendOpenMP
   Support
   )
 
 add_clang_library(clangStaticAnalyzerCheckers
   AnalysisOrderChecker.cpp
   AnalyzerStatsChecker.cpp
   ArrayBoundChecker.cpp
   ArrayBoundCheckerV2.cpp

clang/lib/StaticAnalyzer/Core/CMakeLists.txt

-set(LLVM_LINK_COMPONENTS support)
+set(LLVM_LINK_COMPONENTS
+  FrontendOpenMP
+  Support
+)
 
 add_clang_library(clangStaticAnalyzerCore
   APSIntType.cpp
   AnalysisManager.cpp
   AnalyzerOptions.cpp
   BasicValueFactory.cpp
   BlockCounter.cpp
   BugReporter.cpp

clang/tools/libclang/CIndex.cpp

 namespace {
 class OMPClauseEnqueue : public ConstOMPClauseVisitor<OMPClauseEnqueue> {
   EnqueueVisitor *Visitor;
   /// Process clauses with list of variables.
   template <typename T> void VisitOMPClauseList(T *Node);
 
 public:
   OMPClauseEnqueue(EnqueueVisitor *Visitor) : Visitor(Visitor) {}
-#define OPENMP_CLAUSE(Name, Class) void Visit##Class(const Class *C);
-#include "clang/Basic/OpenMPKinds.def"
+#define OMP_CLAUSE_CLASS(Enum, Str, Class) void Visit##Class(const Class *C);
+#include "llvm/Frontend/OpenMP/OMPKinds.def"
   void VisitOMPClauseWithPreInit(const OMPClauseWithPreInit *C);
   void VisitOMPClauseWithPostUpdate(const OMPClauseWithPostUpdate *C);
 };
 
 void OMPClauseEnqueue::VisitOMPClauseWithPreInit(
     const OMPClauseWithPreInit *C) {
   Visitor->AddStmt(C->getPreInitStmt());
 }

clang/unittests/ASTMatchers/ASTMatchersNarrowingTest.cpp

TEST(HasExternalFormalLinkage, Basic) {
   // Despite having internal semantic linkage, the anonymous namespace member
   // has external linkage because the member has a unique name in all
   // translation units.
   EXPECT_TRUE(matches("namespace { int a = 0; }",
                       namedDecl(hasExternalFormalLinkage())));
 }
 
 TEST(HasDefaultArgument, Basic) {
-  EXPECT_TRUE(matches("void x(int val = 0) {}", 
+  EXPECT_TRUE(matches("void x(int val = 0) {}",
                       parmVarDecl(hasDefaultArgument())));
   EXPECT_TRUE(notMatches("void x(int val) {}",
                       parmVarDecl(hasDefaultArgument())));
 }
 
 TEST(IsArray, Basic) {
   EXPECT_TRUE(matches("struct MyClass {}; MyClass *p1 = new MyClass[10];",
                       cxxNewExpr(isArray())));
TEST(TagDeclKind, MatchesTagDeclKind) {
   EXPECT_TRUE(matches("union U {};", tagDecl(isUnion())));
   EXPECT_TRUE(matches("enum E {};", tagDecl(isEnum())));
 }
 
 TEST(HasTrailingReturn, MatchesTrailingReturn) {
   EXPECT_TRUE(matches("auto Y() -> int { return 0; }",
                       functionDecl(hasTrailingReturn())));
   EXPECT_TRUE(matches("auto X() -> int;", functionDecl(hasTrailingReturn())));
-  EXPECT_TRUE(notMatches("int X() { return 0; }", 
+  EXPECT_TRUE(notMatches("int X() { return 0; }",
                       functionDecl(hasTrailingReturn())));
   EXPECT_TRUE(notMatches("int X();", functionDecl(hasTrailingReturn())));
   EXPECT_TRUE(notMatchesC("void X();", functionDecl(hasTrailingReturn())));
 }
 
 TEST(HasTrailingReturn, MatchesLambdaTrailingReturn) {
   EXPECT_TRUE(matches(
           "auto lambda2 = [](double x, double y) -> double {return x + y;};",

 void x(int x) {
 #pragma omp parallel num_threads(x)
 ;
 })";
   EXPECT_TRUE(notMatchesWithOpenMP(Source4, Matcher));
 }
 
 TEST(OMPExecutableDirective, isAllowedToContainClauseKind) {
-  auto Matcher =
-      ompExecutableDirective(isAllowedToContainClauseKind(OMPC_default));
+  auto Matcher = ompExecutableDirective(
+      isAllowedToContainClauseKind(llvm::omp::OMPC_default));
 
   const std::string Source0 = R"(
 void x() {
 ;
 })";
   EXPECT_TRUE(notMatchesWithOpenMP(Source0, Matcher));
 
   const std::string Source1 = R"(

llvm/include/llvm/Frontend/OpenMP/OMPConstants.h

 LLVM_ENABLE_BITMASK_ENUMS_IN_NAMESPACE();
 
 /// IDs for all OpenMP directives.
 enum class Directive {
 #define OMP_DIRECTIVE(Enum, ...) Enum,
 #include "llvm/Frontend/OpenMP/OMPKinds.def"
 };
 
+/// IDs for all OpenMP clauses.
+enum class Clause {
+#define OMP_CLAUSE(Enum, ...) Enum,
+#include "llvm/Frontend/OpenMP/OMPKinds.def"
+};
+
 /// Make the enum values available in the llvm::omp namespace. This allows us to
 /// write something like OMPD_parallel if we have a `using namespace omp`. At
 /// the same time we do not loose the strong type guarantees of the enum class,
 /// that is we cannot pass an unsigned as Directive without an explicit cast.
 #define OMP_DIRECTIVE(Enum, ...) constexpr auto Enum = omp::Directive::Enum;
+#define OMP_CLAUSE(Enum, ...) constexpr auto Enum = omp::Clause::Enum;
 #include "llvm/Frontend/OpenMP/OMPKinds.def"
 
 /// IDs for all omp runtime library (RTL) functions.
 enum class RuntimeFunction {
 #define OMP_RTL(Enum, ...) Enum,
 #include "llvm/Frontend/OpenMP/OMPKinds.def"
 };
 

 #include "llvm/Frontend/OpenMP/OMPKinds.def"
 
 /// Parse \p Str and return the directive it matches or OMPD_unknown if none.
 Directive getOpenMPDirectiveKind(StringRef Str);
 
 /// Return a textual representation of the directive \p D.
 StringRef getOpenMPDirectiveName(Directive D);
 
+/// Parse \p Str and return the clause it matches or OMPC_unknown if none.
+Clause getOpenMPClauseKind(StringRef Str);
+
+/// Return a textual representation of the clause \p C.
+StringRef getOpenMPClauseName(Clause C);
+
 /// Forward declarations for LLVM-IR types (simple, function and structure) are
 /// generated below. Their names are defined and used in OpenMP/OMPKinds.def.
 /// Here we provide the forward declarations, the initializeTypes function will
 /// provide the values.
 ///
 ///{
 namespace types {
 

llvm/include/llvm/Frontend/OpenMP/OMPKinds.def

 __OMP_DIRECTIVE(unknown)
 
 #undef __OMP_DIRECTIVE_EXT
 #undef __OMP_DIRECTIVE
 #undef OMP_DIRECTIVE
 
 ///}
 
+/// OpenMP Clauses
+///
+///{
+
+#ifndef OMP_CLAUSE
+#define OMP_CLAUSE(Enum, Str, Implicit)
+#endif
+#ifndef OMP_CLAUSE_CLASS
+#define OMP_CLAUSE_CLASS(Enum, Str, Class)
+#endif
+#ifndef OMP_CLAUSE_NO_CLASS
+#define OMP_CLAUSE_NO_CLASS(Enum, Str)
+#endif
+
+#define __OMP_CLAUSE(Name, Class)                                              \
+  OMP_CLAUSE(OMPC_##Name, #Name, /* Implicit */ false)                         \
+  OMP_CLAUSE_CLASS(OMPC_##Name, #Name, Class)
+#define __OMP_CLAUSE_NO_CLASS(Name)                                            \
+  OMP_CLAUSE(OMPC_##Name, #Name, /* Implicit */ false)                         \
+  OMP_CLAUSE_NO_CLASS(OMPC_##Name, #Name)
+#define __OMP_IMPLICIT_CLAUSE_CLASS(Name, Str, Class)                          \
+  OMP_CLAUSE(OMPC_##Name, Str, /* Implicit */ true)                            \
+  OMP_CLAUSE_CLASS(OMPC_##Name, Str, Class)
+#define __OMP_IMPLICIT_CLAUSE_NO_CLASS(Name, Str)                              \
+  OMP_CLAUSE(OMPC_##Name, Str, /* Implicit */ true)                            \
+  OMP_CLAUSE_NO_CLASS(OMPC_##Name, Str)
+
+__OMP_CLAUSE(allocator, OMPAllocatorClause)
+__OMP_CLAUSE(if, OMPIfClause)
+__OMP_CLAUSE(final, OMPFinalClause)
+__OMP_CLAUSE(num_threads, OMPNumThreadsClause)
+__OMP_CLAUSE(safelen, OMPSafelenClause)
+__OMP_CLAUSE(simdlen, OMPSimdlenClause)
+__OMP_CLAUSE(collapse, OMPCollapseClause)
+__OMP_CLAUSE(default, OMPDefaultClause)
+__OMP_CLAUSE(private, OMPPrivateClause)
+__OMP_CLAUSE(firstprivate, OMPFirstprivateClause)
+__OMP_CLAUSE(lastprivate, OMPLastprivateClause)
+__OMP_CLAUSE(shared, OMPSharedClause)
+__OMP_CLAUSE(reduction, OMPReductionClause)
+__OMP_CLAUSE(linear, OMPLinearClause)
+__OMP_CLAUSE(aligned, OMPAlignedClause)
+__OMP_CLAUSE(copyin, OMPCopyinClause)
+__OMP_CLAUSE(copyprivate, OMPCopyprivateClause)
+__OMP_CLAUSE(proc_bind, OMPProcBindClause)
+__OMP_CLAUSE(schedule, OMPScheduleClause)
+__OMP_CLAUSE(ordered, OMPOrderedClause)
+__OMP_CLAUSE(nowait, OMPNowaitClause)
+__OMP_CLAUSE(untied, OMPUntiedClause)
+__OMP_CLAUSE(mergeable, OMPMergeableClause)
+__OMP_CLAUSE(read, OMPReadClause)
+__OMP_CLAUSE(write, OMPWriteClause)
+__OMP_CLAUSE(update, OMPUpdateClause)
+__OMP_CLAUSE(capture, OMPCaptureClause)
+__OMP_CLAUSE(seq_cst, OMPSeqCstClause)
+__OMP_CLAUSE(acq_rel, OMPAcqRelClause)
+__OMP_CLAUSE(acquire, OMPAcquireClause)
+__OMP_CLAUSE(release, OMPReleaseClause)
+__OMP_CLAUSE(relaxed, OMPRelaxedClause)
+__OMP_CLAUSE(depend, OMPDependClause)
+__OMP_CLAUSE(device, OMPDeviceClause)
+__OMP_CLAUSE(threads, OMPThreadsClause)
+__OMP_CLAUSE(simd, OMPSIMDClause)
+__OMP_CLAUSE(map, OMPMapClause)
+__OMP_CLAUSE(num_teams, OMPNumTeamsClause)
+__OMP_CLAUSE(thread_limit, OMPThreadLimitClause)
+__OMP_CLAUSE(priority, OMPPriorityClause)
+__OMP_CLAUSE(grainsize, OMPGrainsizeClause)
+__OMP_CLAUSE(nogroup, OMPNogroupClause)
+__OMP_CLAUSE(num_tasks, OMPNumTasksClause)
+__OMP_CLAUSE(hint, OMPHintClause)
+__OMP_CLAUSE(dist_schedule, OMPDistScheduleClause)
+__OMP_CLAUSE(defaultmap, OMPDefaultmapClause)
+__OMP_CLAUSE(to, OMPToClause)
+__OMP_CLAUSE(from, OMPFromClause)
+__OMP_CLAUSE(use_device_ptr, OMPUseDevicePtrClause)
+__OMP_CLAUSE(is_device_ptr, OMPIsDevicePtrClause)
+__OMP_CLAUSE(task_reduction, OMPTaskReductionClause)
+__OMP_CLAUSE(in_reduction, OMPInReductionClause)
+__OMP_CLAUSE(unified_address, OMPUnifiedAddressClause)
+__OMP_CLAUSE(unified_shared_memory, OMPUnifiedSharedMemoryClause)
+__OMP_CLAUSE(reverse_offload, OMPReverseOffloadClause)
+__OMP_CLAUSE(dynamic_allocators, OMPDynamicAllocatorsClause)
+__OMP_CLAUSE(atomic_default_mem_order, OMPAtomicDefaultMemOrderClause)
+__OMP_CLAUSE(allocate, OMPAllocateClause)
+__OMP_CLAUSE(nontemporal, OMPNontemporalClause)
+__OMP_CLAUSE(order, OMPOrderClause)
+__OMP_CLAUSE(destroy, OMPDestroyClause)
+__OMP_CLAUSE(detach, OMPDetachClause)
+__OMP_CLAUSE(inclusive, OMPInclusiveClause)
+__OMP_CLAUSE(exclusive, OMPExclusiveClause)
+
+__OMP_CLAUSE_NO_CLASS(uniform)
+__OMP_CLAUSE_NO_CLASS(device_type)
+__OMP_CLAUSE_NO_CLASS(match)
+
+__OMP_IMPLICIT_CLAUSE_CLASS(depobj, "depobj", OMPDepobjClause)
+__OMP_IMPLICIT_CLAUSE_CLASS(flush, "flush", OMPFlushClause)
+
+__OMP_IMPLICIT_CLAUSE_NO_CLASS(threadprivate, "threadprivate or thread local")
+__OMP_IMPLICIT_CLAUSE_NO_CLASS(unknown, "unknown")
+
+#undef __OMP_IMPLICIT_CLAUSE_NO_CLASS
+#undef __OMP_IMPLICIT_CLAUSE_CLASS
+#undef __OMP_CLAUSE
+#undef OMP_CLAUSE_NO_CLASS
+#undef OMP_CLAUSE_CLASS
+#undef OMP_CLAUSE
+
+///}
+
 /// Types used in runtime structs or runtime functions
 ///
 ///{
 
 #ifndef OMP_TYPE
 #define OMP_TYPE(VarName, InitValue)
 #endif
 

 __OMP_RTL(omp_set_dynamic, false, Void, Int32)
 __OMP_RTL(omp_set_nested, false, Void, Int32)
 __OMP_RTL(omp_set_schedule, false, Void, Int32, Int32)
 __OMP_RTL(omp_set_max_active_levels, false, Void, Int32)
 
 __OMP_RTL(__kmpc_master, false, Int32, IdentPtr, Int32)
 __OMP_RTL(__kmpc_end_master, false, Void, IdentPtr, Int32)
 __OMP_RTL(__kmpc_critical, false, Void, IdentPtr, Int32, KmpCriticalNamePtrTy)
-__OMP_RTL(__kmpc_critical_with_hint, false, Void, IdentPtr, Int32, KmpCriticalNamePtrTy, Int32)
-__OMP_RTL(__kmpc_end_critical, false, Void, IdentPtr, Int32, KmpCriticalNamePtrTy)
+__OMP_RTL(__kmpc_critical_with_hint, false, Void, IdentPtr, Int32,
+          KmpCriticalNamePtrTy, Int32)
+__OMP_RTL(__kmpc_end_critical, false, Void, IdentPtr, Int32,
+          KmpCriticalNamePtrTy)
 
 __OMP_RTL(__last, false, Void, )
 
 #undef __OMP_RTL
 #undef OMP_RTL
 
 #define EnumAttr(Kind) Attribute::get(Ctx, Attribute::AttrKind::Kind)
 #define AttributeSet(...)                                                      \

llvm/lib/Frontend/OpenMP/OMPConstants.cpp

 #define OMP_DIRECTIVE(Enum, Str)                                               \
   case Enum:                                                                   \
     return Str;
 #include "llvm/Frontend/OpenMP/OMPKinds.def"
   }
   llvm_unreachable("Invalid OpenMP directive kind");
 }
 
+Clause llvm::omp::getOpenMPClauseKind(StringRef Str) {
+  return llvm::StringSwitch<Clause>(Str)
+#define OMP_CLAUSE(Enum, Str, Implicit)                                        \
+  .Case(Str, Implicit ? OMPC_unknown : Enum)
+#include "llvm/Frontend/OpenMP/OMPKinds.def"
+      .Default(OMPC_unknown);
+}
+
+StringRef llvm::omp::getOpenMPClauseName(Clause C) {
+  switch (C) {
+#define OMP_CLAUSE(Enum, Str, ...)                                             \
+  case Enum:                                                                   \
+    return Str;
+#include "llvm/Frontend/OpenMP/OMPKinds.def"
+  }
+  llvm_unreachable("Invalid OpenMP clause kind");
+}
+
 /// Declarations for LLVM-IR types (simple, array, function and structure) are
 /// generated below. Their names are defined and used in OpenMPKinds.def. Here
 /// we provide the declarations, the initializeTypes function will provide the
 /// values.
 ///
 ///{
 #define OMP_TYPE(VarName, InitValue) Type *llvm::omp::types::VarName = nullptr;
 #define OMP_ARRAY_TYPE(VarName, ElemTy, ArraySize)                             \