Revert "[openmp] Remove clause from OMPKinds.def and use OMP.td info"

This reverts commit a7b2847216.

failing buildbot on warnings

clang/include/clang/AST/ASTFwd.h

@@ -27,9 +27,9 @@ class Type;
 #include "clang/AST/TypeNodes.inc"
 class CXXCtorInitializer;
 class OMPClause;
-#define GEN_CLANG_CLAUSE_CLASS
+#define OMP_CLAUSE_CLASS(Enum, Str, Class) class Class;
-#define CLAUSE_CLASS(Enum, Str, Class) class Class;
+#include "llvm/Frontend/OpenMP/OMPKinds.def"
-#include "llvm/Frontend/OpenMP/OMP.cpp.inc"
+
 
 } // end namespace clang
 

clang/include/clang/AST/ASTTypeTraits.h

@@ -147,9 +147,8 @@ private:
 #define TYPE(DERIVED, BASE) NKI_##DERIVED##Type,
 #include "clang/AST/TypeNodes.inc"
     NKI_OMPClause,
-#define GEN_CLANG_CLAUSE_CLASS
+#define OMP_CLAUSE_CLASS(Enum, Str, Class) NKI_##Class,
-#define CLAUSE_CLASS(Enum, Str, Class) NKI_##Class,
+#include "llvm/Frontend/OpenMP/OMPKinds.def"
-#include "llvm/Frontend/OpenMP/OMP.cpp.inc"
     NKI_NumberOfKinds
   };
 
@@ -206,9 +205,8 @@ KIND_TO_KIND_ID(CXXBaseSpecifier)
 #include "clang/AST/StmtNodes.inc"
 #define TYPE(DERIVED, BASE) KIND_TO_KIND_ID(DERIVED##Type)
 #include "clang/AST/TypeNodes.inc"
-#define GEN_CLANG_CLAUSE_CLASS
+#define OMP_CLAUSE_CLASS(Enum, Str, Class) KIND_TO_KIND_ID(Class)
-#define CLAUSE_CLASS(Enum, Str, Class) KIND_TO_KIND_ID(Class)
+#include "llvm/Frontend/OpenMP/OMPKinds.def"
-#include "llvm/Frontend/OpenMP/OMP.cpp.inc"
 #undef KIND_TO_KIND_ID
 
 inline raw_ostream &operator<<(raw_ostream &OS, ASTNodeKind K) {

clang/include/clang/AST/OpenMPClause.h

@@ -7758,22 +7758,20 @@ public:
 #define DISPATCH(CLASS) \
   return static_cast<ImplClass*>(this)->Visit##CLASS(static_cast<PTR(CLASS)>(S))
 
-#define GEN_CLANG_CLAUSE_CLASS
+#define OMP_CLAUSE_CLASS(Enum, Str, Class) \
-#define CLAUSE_CLASS(Enum, Str, Class)                                         \
+  RetTy Visit ## Class (PTR(Class) S) { DISPATCH(Class); }
-  RetTy Visit##Class(PTR(Class) S) { DISPATCH(Class); }
+#include "llvm/Frontend/OpenMP/OMPKinds.def"
-#include "llvm/Frontend/OpenMP/OMP.cpp.inc"
 
   RetTy Visit(PTR(OMPClause) S) {
     // Top switch clause: visit each OMPClause.
     switch (S->getClauseKind()) {
-#define GEN_CLANG_CLAUSE_CLASS
+#define OMP_CLAUSE_CLASS(Enum, Str, Class)                                     \
-#define CLAUSE_CLASS(Enum, Str, Class)                                         \
   case llvm::omp::Clause::Enum:                                                \
     return Visit##Class(static_cast<PTR(Class)>(S));
-#define CLAUSE_NO_CLASS(Enum, Str)                                             \
+#define OMP_CLAUSE_NO_CLASS(Enum, Str)                                         \
   case llvm::omp::Clause::Enum:                                                \
     break;
-#include "llvm/Frontend/OpenMP/OMP.cpp.inc"
+#include "llvm/Frontend/OpenMP/OMPKinds.def"
     default:
       break;
     }
@@ -7806,9 +7804,9 @@ public:
   OMPClausePrinter(raw_ostream &OS, const PrintingPolicy &Policy)
       : OS(OS), Policy(Policy) {}
 
-#define GEN_CLANG_CLAUSE_CLASS
+#define OMP_CLAUSE_CLASS(Enum, Str, Class)                                     \
-#define CLAUSE_CLASS(Enum, Str, Class) void Visit##Class(Class *S);
+  void Visit##Class(Class *S);
-#include "llvm/Frontend/OpenMP/OMP.cpp.inc"
+#include "llvm/Frontend/OpenMP/OMPKinds.def"
 };
 
 struct OMPTraitProperty {

clang/include/clang/AST/RecursiveASTVisitor.h

@@ -488,9 +488,8 @@ private:
   bool TraverseOMPExecutableDirective(OMPExecutableDirective *S);
   bool TraverseOMPLoopDirective(OMPLoopDirective *S);
   bool TraverseOMPClause(OMPClause *C);
-#define GEN_CLANG_CLAUSE_CLASS
+#define OMP_CLAUSE_CLASS(Enum, Str, Class) bool Visit##Class(Class *C);
-#define CLAUSE_CLASS(Enum, Str, Class) bool Visit##Class(Class *C);
+#include "llvm/Frontend/OpenMP/OMPKinds.def"
-#include "llvm/Frontend/OpenMP/OMP.cpp.inc"
   /// Process clauses with list of variables.
   template <typename T> bool VisitOMPClauseList(T *Node);
   /// Process clauses with pre-initis.
@@ -2950,15 +2949,14 @@ bool RecursiveASTVisitor<Derived>::TraverseOMPClause(OMPClause *C) {
   if (!C)
     return true;
   switch (C->getClauseKind()) {
-#define GEN_CLANG_CLAUSE_CLASS
+#define OMP_CLAUSE_CLASS(Enum, Str, Class)                                     \
-#define CLAUSE_CLASS(Enum, Str, Class)                                         \
   case llvm::omp::Clause::Enum:                                                \
     TRY_TO(Visit##Class(static_cast<Class *>(C)));                             \
     break;
-#define CLAUSE_NO_CLASS(Enum, Str)                                             \
+#define OMP_CLAUSE_NO_CLASS(Enum, Str)                                         \
   case llvm::omp::Clause::Enum:                                                \
     break;
-#include "llvm/Frontend/OpenMP/OMP.cpp.inc"
+#include "llvm/Frontend/OpenMP/OMPKinds.def"
   default:
     break;
   }

clang/lib/AST/ASTTypeTraits.cpp

@@ -21,29 +21,28 @@
 using namespace clang;
 
 const ASTNodeKind::KindInfo ASTNodeKind::AllKindInfo[] = {
-    {NKI_None, "<None>"},
+  { NKI_None, "<None>" },
-    {NKI_None, "TemplateArgument"},
+  { NKI_None, "TemplateArgument" },
-    {NKI_None, "TemplateArgumentLoc"},
+  { NKI_None, "TemplateArgumentLoc" },
-    {NKI_None, "TemplateName"},
+  { NKI_None, "TemplateName" },
-    {NKI_None, "NestedNameSpecifierLoc"},
+  { NKI_None, "NestedNameSpecifierLoc" },
-    {NKI_None, "QualType"},
+  { NKI_None, "QualType" },
-    {NKI_None, "TypeLoc"},
+  { NKI_None, "TypeLoc" },
-    {NKI_None, "CXXBaseSpecifier"},
+  { NKI_None, "CXXBaseSpecifier" },
-    {NKI_None, "CXXCtorInitializer"},
+  { NKI_None, "CXXCtorInitializer" },
-    {NKI_None, "NestedNameSpecifier"},
+  { NKI_None, "NestedNameSpecifier" },
-    {NKI_None, "Decl"},
+  { NKI_None, "Decl" },
 #define DECL(DERIVED, BASE) { NKI_##BASE, #DERIVED "Decl" },
 #include "clang/AST/DeclNodes.inc"
-    {NKI_None, "Stmt"},
+  { NKI_None, "Stmt" },
 #define STMT(DERIVED, BASE) { NKI_##BASE, #DERIVED },
 #include "clang/AST/StmtNodes.inc"
-    {NKI_None, "Type"},
+  { NKI_None, "Type" },
 #define TYPE(DERIVED, BASE) { NKI_##BASE, #DERIVED "Type" },
 #include "clang/AST/TypeNodes.inc"
-    {NKI_None, "OMPClause"},
+  { NKI_None, "OMPClause" },
-#define GEN_CLANG_CLAUSE_CLASS
+#define OMP_CLAUSE_CLASS(Enum, Str, Class) {NKI_OMPClause, #Class},
-#define CLAUSE_CLASS(Enum, Str, Class) {NKI_OMPClause, #Class},
+#include "llvm/Frontend/OpenMP/OMPKinds.def"
-#include "llvm/Frontend/OpenMP/OMP.cpp.inc"
 };
 
 bool ASTNodeKind::isBaseOf(ASTNodeKind Other, unsigned *Distance) const {
@@ -114,16 +113,15 @@ ASTNodeKind ASTNodeKind::getFromNode(const Type &T) {
 
 ASTNodeKind ASTNodeKind::getFromNode(const OMPClause &C) {
   switch (C.getClauseKind()) {
-#define GEN_CLANG_CLAUSE_CLASS
+#define OMP_CLAUSE_CLASS(Enum, Str, Class)                                     \
-#define CLAUSE_CLASS(Enum, Str, Class)                                         \
   case llvm::omp::Clause::Enum:                                                \
     return ASTNodeKind(NKI_##Class);
-#define CLAUSE_NO_CLASS(Enum, Str)                                             \
+#define OMP_CLAUSE_NO_CLASS(Enum, Str)                                         \
   case llvm::omp::Clause::Enum:                                                \
     llvm_unreachable("unexpected OpenMP clause kind");
   default:
     break;
-#include "llvm/Frontend/OpenMP/OMP.cpp.inc"
+#include "llvm/Frontend/OpenMP/OMPKinds.def"
   }
   llvm_unreachable("invalid stmt kind");
 }

clang/lib/AST/OpenMPClause.cpp

@@ -32,22 +32,20 @@ OMPClause::child_range OMPClause::children() {
   switch (getClauseKind()) {
   default:
     break;
-#define GEN_CLANG_CLAUSE_CLASS
+#define OMP_CLAUSE_CLASS(Enum, Str, Class)                                           \
-#define CLAUSE_CLASS(Enum, Str, Class)                                         \
   case Enum:                                                                   \
     return static_cast<Class *>(this)->children();
-#include "llvm/Frontend/OpenMP/OMP.cpp.inc"
+#include "llvm/Frontend/OpenMP/OMPKinds.def"
   }
   llvm_unreachable("unknown OMPClause");
 }
 
 OMPClause::child_range OMPClause::used_children() {
   switch (getClauseKind()) {
-#define GEN_CLANG_CLAUSE_CLASS
+#define OMP_CLAUSE_CLASS(Enum, Str, Class)                                           \
-#define CLAUSE_CLASS(Enum, Str, Class)                                         \
   case Enum:                                                                   \
     return static_cast<Class *>(this)->used_children();
-#include "llvm/Frontend/OpenMP/OMP.cpp.inc"
+#include "llvm/Frontend/OpenMP/OMPKinds.def"
   case OMPC_threadprivate:
   case OMPC_uniform:
   case OMPC_device_type:

clang/lib/AST/StmtProfile.cpp

@@ -414,9 +414,8 @@ class OMPClauseProfiler : public ConstOMPClauseVisitor<OMPClauseProfiler> {
 
 public:
   OMPClauseProfiler(StmtProfiler *P) : Profiler(P) { }
-#define GEN_CLANG_CLAUSE_CLASS
+#define OMP_CLAUSE_CLASS(Enum, Str, Class) void Visit##Class(const Class *C);
-#define CLAUSE_CLASS(Enum, Str, Class) void Visit##Class(const Class *C);
+#include "llvm/Frontend/OpenMP/OMPKinds.def"
-#include "llvm/Frontend/OpenMP/OMP.cpp.inc"
   void VistOMPClauseWithPreInit(const OMPClauseWithPreInit *C);
   void VistOMPClauseWithPostUpdate(const OMPClauseWithPostUpdate *C);
 };

clang/lib/ASTMatchers/Dynamic/Marshallers.cpp

@@ -89,9 +89,8 @@ llvm::Optional<std::string>
 clang::ast_matchers::dynamic::internal::ArgTypeTraits<
     clang::OpenMPClauseKind>::getBestGuess(const VariantValue &Value) {
   static constexpr llvm::StringRef Allowed[] = {
-#define GEN_CLANG_CLAUSE_CLASS
+#define OMP_CLAUSE_CLASS(Enum, Str, Class) #Enum,
-#define CLAUSE_CLASS(Enum, Str, Class) #Enum,
+#include "llvm/Frontend/OpenMP/OMPKinds.def"
-#include "llvm/Frontend/OpenMP/OMP.cpp.inc"
   };
   if (Value.isString())
     return ::getBestGuess(Value.getString(), llvm::makeArrayRef(Allowed),

clang/lib/ASTMatchers/Dynamic/Marshallers.h

@@ -239,9 +239,8 @@ template <> struct ArgTypeTraits<OpenMPClauseKind> {
 private:
   static Optional<OpenMPClauseKind> getClauseKind(llvm::StringRef ClauseKind) {
     return llvm::StringSwitch<Optional<OpenMPClauseKind>>(ClauseKind)
-#define GEN_CLANG_CLAUSE_CLASS
+#define OMP_CLAUSE_CLASS(Enum, Str, Class) .Case(#Enum, llvm::omp::Clause::Enum)
-#define CLAUSE_CLASS(Enum, Str, Class) .Case(#Enum, llvm::omp::Clause::Enum)
+#include "llvm/Frontend/OpenMP/OMPKinds.def"
-#include "llvm/Frontend/OpenMP/OMP.cpp.inc"
         .Default(llvm::None);
   }
 

clang/lib/Sema/TreeTransform.h

@@ -731,11 +731,10 @@ public:
 #define ABSTRACT_STMT(Stmt)
 #include "clang/AST/StmtNodes.inc"
 
-#define GEN_CLANG_CLAUSE_CLASS
+#define OMP_CLAUSE_CLASS(Enum, Str, Class)                                           \
-#define CLAUSE_CLASS(Enum, Str, Class)                                         \
+  LLVM_ATTRIBUTE_NOINLINE \
-  LLVM_ATTRIBUTE_NOINLINE                                                      \
+  OMPClause *Transform ## Class(Class *S);
-  OMPClause *Transform##Class(Class *S);
+#include "llvm/Frontend/OpenMP/OMPKinds.def"
-#include "llvm/Frontend/OpenMP/OMP.cpp.inc"
 
   /// Build a new qualified type given its unqualified type and type location.
   ///
@@ -3692,11 +3691,10 @@ OMPClause *TreeTransform<Derived>::TransformOMPClause(OMPClause *S) {
   switch (S->getClauseKind()) {
   default: break;
   // Transform individual clause nodes
-#define GEN_CLANG_CLAUSE_CLASS
+#define OMP_CLAUSE_CLASS(Enum, Str, Class) \
-#define CLAUSE_CLASS(Enum, Str, Class)                                         \
   case Enum:                                                                   \
-    return getDerived().Transform##Class(cast<Class>(S));
+    return getDerived().Transform ## Class(cast<Class>(S));
-#include "llvm/Frontend/OpenMP/OMP.cpp.inc"
+#include "llvm/Frontend/OpenMP/OMPKinds.def"
   }
 
   return S;

clang/lib/Serialization/ASTReader.cpp

@@ -11819,9 +11819,9 @@ class OMPClauseReader : public OMPClauseVisitor<OMPClauseReader> {
 public:
   OMPClauseReader(ASTRecordReader &Record)
       : Record(Record), Context(Record.getContext()) {}
-#define GEN_CLANG_CLAUSE_CLASS
+
-#define CLAUSE_CLASS(Enum, Str, Class) void Visit##Class(Class *C);
+#define OMP_CLAUSE_CLASS(Enum, Str, Class) void Visit##Class(Class *C);
-#include "llvm/Frontend/OpenMP/OMP.cpp.inc"
+#include "llvm/Frontend/OpenMP/OMPKinds.def"
   OMPClause *readClause();
   void VisitOMPClauseWithPreInit(OMPClauseWithPreInit *C);
   void VisitOMPClauseWithPostUpdate(OMPClauseWithPostUpdate *C);

clang/lib/Serialization/ASTWriter.cpp

@@ -6210,9 +6210,8 @@ class OMPClauseWriter : public OMPClauseVisitor<OMPClauseWriter> {
 
 public:
   OMPClauseWriter(ASTRecordWriter &Record) : Record(Record) {}
-#define GEN_CLANG_CLAUSE_CLASS
+#define OMP_CLAUSE_CLASS(Enum, Str, Class) void Visit##Class(Class *S);
-#define CLAUSE_CLASS(Enum, Str, Class) void Visit##Class(Class *S);
+#include "llvm/Frontend/OpenMP/OMPKinds.def"
-#include "llvm/Frontend/OpenMP/OMP.cpp.inc"
   void writeClause(OMPClause *C);
   void VisitOMPClauseWithPreInit(OMPClauseWithPreInit *C);
   void VisitOMPClauseWithPostUpdate(OMPClauseWithPostUpdate *C);

clang/tools/libclang/CIndex.cpp

@@ -2174,9 +2174,8 @@ class OMPClauseEnqueue : public ConstOMPClauseVisitor<OMPClauseEnqueue> {
 
 public:
   OMPClauseEnqueue(EnqueueVisitor *Visitor) : Visitor(Visitor) {}
-#define GEN_CLANG_CLAUSE_CLASS
+#define OMP_CLAUSE_CLASS(Enum, Str, Class) void Visit##Class(const Class *C);
-#define CLAUSE_CLASS(Enum, Str, Class) void Visit##Class(const Class *C);
+#include "llvm/Frontend/OpenMP/OMPKinds.def"
-#include "llvm/Frontend/OpenMP/OMP.cpp.inc"
   void VisitOMPClauseWithPreInit(const OMPClauseWithPreInit *C);
   void VisitOMPClauseWithPostUpdate(const OMPClauseWithPostUpdate *C);
 };

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

@@ -7,16 +7,130 @@
 //===----------------------------------------------------------------------===//
 /// \file
 ///
-/// This file defines the list of supported OpenMP runtime
+/// This file defines the list of supported OpenMP directives, clauses, runtime
 /// calls, and other things that need to be listed in enums.
 ///
 /// This file is under transition to OMP.td with TableGen code generation.
 ///
 //===----------------------------------------------------------------------===//
 
-/// OpenMP Directives, combined directives and Clauses
+/// OpenMP Directives and combined directives
 /// - Moved to OMP.td
 
+/// 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(uses_allocators, OMPUsesAllocatorsClause)
+__OMP_CLAUSE(affinity, OMPAffinityClause)
+__OMP_CLAUSE(use_device_addr, OMPUseDeviceAddrClause)
+
+__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
 ///
 ///{

llvm/include/llvm/TableGen/DirectiveEmitter.h

@@ -182,7 +182,7 @@ public:
     return Def->getValueAsString("defaultValue");
   }
 
-  bool isImplicit() const { return Def->getValueAsBit("isImplicit"); }
+  bool isImplict() const { return Def->getValueAsBit("isImplicit"); }
 };
 
 // Wrapper class that contains VersionedClause's information defined in

llvm/test/TableGen/directive2.td

@@ -23,15 +23,10 @@ def TDLC_ClauseB : Clause<"clauseb"> {
   let isValueList = 1;
 }
 def TDLC_ClauseC : Clause<"clausec"> {
-  let clangClass = "ClauseC";
   let flangClassValue = "Name";
   let defaultValue = "*";
   let isValueOptional = 1;
 }
-def TDLC_ClauseD : Clause<"claused"> {
-  let clangClass = "ClauseD";
-  let isImplicit = 1;
-}
 
 def TDL_DirA : Directive<"dira"> {
   let allowedClauses = [
@@ -58,10 +53,9 @@ def TDL_DirA : Directive<"dira"> {
 // CHECK-NEXT:    TDLC_clausea,
 // CHECK-NEXT:    TDLC_clauseb,
 // CHECK-NEXT:    TDLC_clausec,
-// CHECK-NEXT:    TDLC_claused,
 // CHECK-NEXT:  };
 // CHECK-EMPTY:
-// CHECK-NEXT:  static constexpr std::size_t Clause_enumSize = 4;
+// CHECK-NEXT:  static constexpr std::size_t Clause_enumSize = 3;
 // CHECK-EMPTY:
 // CHECK-NEXT:  // Enumeration helper functions
 // CHECK-NEXT:  Directive getTdlDirectiveKind(llvm::StringRef Str);
@@ -107,7 +101,6 @@ def TDL_DirA : Directive<"dira"> {
 // IMPL-NEXT:      .Case("clausea",TDLC_clauseb)
 // IMPL-NEXT:      .Case("clauseb",TDLC_clauseb)
 // IMPL-NEXT:      .Case("clausec",TDLC_clausec)
-// IMPL-NEXT:      .Case("claused",TDLC_clauseb)
 // IMPL-NEXT:      .Default(TDLC_clauseb);
 // IMPL-NEXT:  }
 // IMPL-EMPTY:
@@ -119,8 +112,6 @@ def TDL_DirA : Directive<"dira"> {
 // IMPL-NEXT:        return "clauseb";
 // IMPL-NEXT:      case TDLC_clausec:
 // IMPL-NEXT:        return "clausec";
-// IMPL-NEXT:      case TDLC_claused:
-// IMPL-NEXT:        return "claused";
 // IMPL-NEXT:    }
 // IMPL-NEXT:    llvm_unreachable("Invalid Tdl Clause kind");
 // IMPL-NEXT:  }
@@ -192,7 +183,6 @@ def TDL_DirA : Directive<"dira"> {
 // GEN-NEXT:  EMPTY_CLASS(Clausea);
 // GEN-NEXT:  WRAPPER_CLASS(Clauseb, std::list<IntExpr>);
 // GEN-NEXT:  WRAPPER_CLASS(Clausec, std::optional<Name>);
-// GEN-NEXT:  EMPTY_CLASS(Claused);
 // GEN-EMPTY:
 // GEN-NEXT:  #endif // GEN_FLANG_CLAUSE_PARSER_CLASSES
 // GEN-EMPTY:
@@ -202,7 +192,6 @@ def TDL_DirA : Directive<"dira"> {
 // GEN-NEXT:  Clausea
 // GEN-NEXT:  , Clauseb
 // GEN-NEXT:  , Clausec
-// GEN-NEXT:  , Claused
 // GEN-EMPTY:
 // GEN-NEXT:  #endif // GEN_FLANG_CLAUSE_PARSER_CLASSES_LIST
 // GEN-EMPTY:
@@ -212,7 +201,6 @@ def TDL_DirA : Directive<"dira"> {
 // GEN-NEXT:  NODE(TdlClause, Clausea)
 // GEN-NEXT:  NODE(TdlClause, Clauseb)
 // GEN-NEXT:  NODE(TdlClause, Clausec)
-// GEN-NEXT:  NODE(TdlClause, Claused)
 // GEN-EMPTY:
 // GEN-NEXT:  #endif // GEN_FLANG_DUMP_PARSE_TREE_CLAUSES
 // GEN-EMPTY:
@@ -235,47 +223,5 @@ def TDL_DirA : Directive<"dira"> {
 // GEN-NEXT:    Put("*");
 // GEN-NEXT:    Put(")");
 // GEN-NEXT:  }
-// GEN-NEXT:  void Before(const TdlClause::Claused &) { Word("CLAUSED"); }
 // GEN-EMPTY:
 // GEN-NEXT:  #endif // GEN_FLANG_CLAUSE_UNPARSE
-
-// GEN:       #ifdef GEN_CLANG_CLAUSE_CLASS
-// GEN-NEXT:  #undef GEN_CLANG_CLAUSE_CLASS
-// GEN-EMPTY:
-// GEN-NEXT:  #ifndef CLAUSE
-// GEN-NEXT:  #define CLAUSE(Enum, Str, Implicit)
-// GEN-NEXT:  #endif
-// GEN-NEXT:  #ifndef CLAUSE_CLASS
-// GEN-NEXT:  #define CLAUSE_CLASS(Enum, Str, Class)
-// GEN-NEXT:  #endif
-// GEN-NEXT:  #ifndef CLAUSE_NO_CLASS
-// GEN-NEXT:  #define CLAUSE_NO_CLASS(Enum, Str)
-// GEN-NEXT:  #endif
-// GEN-EMPTY:
-// GEN-NEXT:  #define __CLAUSE(Name, Class)                      \
-// GEN-NEXT:    CLAUSE(TDLC_##Name, #Name, /* Implicit */ false) \
-// GEN-NEXT:    CLAUSE_CLASS(TDLC_##Name, #Name, Class)
-// GEN-NEXT:  #define __CLAUSE_NO_CLASS(Name)                    \
-// GEN-NEXT:    CLAUSE(TDLC_##Name, #Name, /* Implicit */ false) \
-// GEN-NEXT:    CLAUSE_NO_CLASS(TDLC_##Name, #Name)
-// GEN-NEXT:  #define __IMPLICIT_CLAUSE_CLASS(Name, Str, Class)  \
-// GEN-NEXT:    CLAUSE(TDLC_##Name, Str, /* Implicit */ true)    \
-// GEN-NEXT:  CLAUSE_CLASS(TDLC_##Name, Str, Class)
-// GEN-NEXT:  #define __IMPLICIT_CLAUSE_NO_CLASS(Name, Str)      \
-// GEN-NEXT:    CLAUSE(TDLC_##Name, Str, /* Implicit */ true)    \
-// GEN-NEXT:  CLAUSE_NO_CLASS(TDLC_##Name, Str)
-// GEN-EMPTY:
-// GEN-NEXT:  __IMPLICIT_CLAUSE_NO_CLASS(clausea, "clausea")
-// GEN-NEXT:  __CLAUSE_NO_CLASS(clauseb)
-// GEN-NEXT:  __CLAUSE(clausec, ClauseC)
-// GEN-NEXT:  __IMPLICIT_CLAUSE_CLASS(claused, "claused", ClauseD)
-// GEN-EMPTY:
-// GEN-NEXT:  #undef __IMPLICIT_CLAUSE_NO_CLASS
-// GEN-NEXT:  #undef __IMPLICIT_CLAUSE_CLASS
-// GEN-NEXT:  #undef __CLAUSE
-// GEN-NEXT:  #undef CLAUSE_NO_CLASS
-// GEN-NEXT:  #undef CLAUSE_CLASS
-// GEN-NEXT:  #undef CLAUSE
-// GEN-EMPTY:
-// GEN-NEXT:  #endif // GEN_CLANG_CLAUSE_CLASS
-

llvm/utils/TableGen/DirectiveEmitter.cpp

@@ -645,72 +645,6 @@ void EmitDirectivesFlangImpl(const DirectiveLanguage &DirLang,
   GenerateFlangClauseUnparse(DirLang, OS);
 }
 
-void GenerateClauseClassMacro(const DirectiveLanguage &DirLang,
-                              raw_ostream &OS) {
-  // Generate macros style information for legacy code in clang
-  IfDefScope Scope("GEN_CLANG_CLAUSE_CLASS", OS);
-
-  OS << "\n";
-
-  OS << "#ifndef CLAUSE\n";
-  OS << "#define CLAUSE(Enum, Str, Implicit)\n";
-  OS << "#endif\n";
-  OS << "#ifndef CLAUSE_CLASS\n";
-  OS << "#define CLAUSE_CLASS(Enum, Str, Class)\n";
-  OS << "#endif\n";
-  OS << "#ifndef CLAUSE_NO_CLASS\n";
-  OS << "#define CLAUSE_NO_CLASS(Enum, Str)\n";
-  OS << "#endif\n";
-  OS << "\n";
-  OS << "#define __CLAUSE(Name, Class)                      \\\n";
-  OS << "  CLAUSE(" << DirLang.getClausePrefix()
-     << "##Name, #Name, /* Implicit */ false) \\\n";
-  OS << "  CLAUSE_CLASS(" << DirLang.getClausePrefix()
-     << "##Name, #Name, Class)\n";
-  OS << "#define __CLAUSE_NO_CLASS(Name)                    \\\n";
-  OS << "  CLAUSE(" << DirLang.getClausePrefix()
-     << "##Name, #Name, /* Implicit */ false) \\\n";
-  OS << "  CLAUSE_NO_CLASS(" << DirLang.getClausePrefix() << "##Name, #Name)\n";
-  OS << "#define __IMPLICIT_CLAUSE_CLASS(Name, Str, Class)  \\\n";
-  OS << "  CLAUSE(" << DirLang.getClausePrefix()
-     << "##Name, Str, /* Implicit */ true)    \\\n";
-  OS << "  CLAUSE_CLASS(" << DirLang.getClausePrefix()
-     << "##Name, Str, Class)\n";
-  OS << "#define __IMPLICIT_CLAUSE_NO_CLASS(Name, Str)      \\\n";
-  OS << "  CLAUSE(" << DirLang.getClausePrefix()
-     << "##Name, Str, /* Implicit */ true)    \\\n";
-  OS << "  CLAUSE_NO_CLASS(" << DirLang.getClausePrefix() << "##Name, Str)\n";
-  OS << "\n";
-
-  for (const auto &R : DirLang.getClauses()) {
-    Clause C{R};
-    if (C.getClangClass().empty()) { // NO_CLASS
-      if (C.isImplicit()) {
-        OS << "__IMPLICIT_CLAUSE_NO_CLASS(" << C.getFormattedName() << ", \""
-           << C.getFormattedName() << "\")\n";
-      } else {
-        OS << "__CLAUSE_NO_CLASS(" << C.getFormattedName() << ")\n";
-      }
-    } else { // CLASS
-      if (C.isImplicit()) {
-        OS << "__IMPLICIT_CLAUSE_CLASS(" << C.getFormattedName() << ", \""
-           << C.getFormattedName() << "\", " << C.getClangClass() << ")\n";
-      } else {
-        OS << "__CLAUSE(" << C.getFormattedName() << ", " << C.getClangClass()
-           << ")\n";
-      }
-    }
-  }
-
-  OS << "\n";
-  OS << "#undef __IMPLICIT_CLAUSE_NO_CLASS\n";
-  OS << "#undef __IMPLICIT_CLAUSE_CLASS\n";
-  OS << "#undef __CLAUSE\n";
-  OS << "#undef CLAUSE_NO_CLASS\n";
-  OS << "#undef CLAUSE_CLASS\n";
-  OS << "#undef CLAUSE\n";
-}
-
 // Generate the implemenation section for the enumeration in the directive
 // language.
 void EmitDirectivesGen(RecordKeeper &Records, raw_ostream &OS) {
@@ -719,8 +653,6 @@ void EmitDirectivesGen(RecordKeeper &Records, raw_ostream &OS) {
     return;
 
   EmitDirectivesFlangImpl(DirLang, OS);
-
-  GenerateClauseClassMacro(DirLang, OS);
 }
 
 // Generate the implemenation for the enumeration in the directive