diff --git a/clang/include/clang/AST/ASTFwd.h b/clang/include/clang/AST/ASTFwd.h --- a/clang/include/clang/AST/ASTFwd.h +++ b/clang/include/clang/AST/ASTFwd.h @@ -27,9 +27,9 @@ #include "clang/AST/TypeNodes.inc" class CXXCtorInitializer; class OMPClause; -#define OMP_CLAUSE_CLASS(Enum, Str, Class) class Class; -#include "llvm/Frontend/OpenMP/OMPKinds.def" - +#define GEN_CLANG_CLAUSE_CLASS +#define CLAUSE_CLASS(Enum, Str, Class) class Class; +#include "llvm/Frontend/OpenMP/OMP.inc" } // end namespace clang diff --git a/clang/include/clang/AST/ASTTypeTraits.h b/clang/include/clang/AST/ASTTypeTraits.h --- a/clang/include/clang/AST/ASTTypeTraits.h +++ b/clang/include/clang/AST/ASTTypeTraits.h @@ -147,8 +147,9 @@ #define TYPE(DERIVED, BASE) NKI_##DERIVED##Type, #include "clang/AST/TypeNodes.inc" NKI_OMPClause, -#define OMP_CLAUSE_CLASS(Enum, Str, Class) NKI_##Class, -#include "llvm/Frontend/OpenMP/OMPKinds.def" +#define GEN_CLANG_CLAUSE_CLASS +#define CLAUSE_CLASS(Enum, Str, Class) NKI_##Class, +#include "llvm/Frontend/OpenMP/OMP.inc" NKI_NumberOfKinds }; @@ -205,8 +206,9 @@ #include "clang/AST/StmtNodes.inc" #define TYPE(DERIVED, BASE) KIND_TO_KIND_ID(DERIVED##Type) #include "clang/AST/TypeNodes.inc" -#define OMP_CLAUSE_CLASS(Enum, Str, Class) KIND_TO_KIND_ID(Class) -#include "llvm/Frontend/OpenMP/OMPKinds.def" +#define GEN_CLANG_CLAUSE_CLASS +#define CLAUSE_CLASS(Enum, Str, Class) KIND_TO_KIND_ID(Class) +#include "llvm/Frontend/OpenMP/OMP.inc" #undef KIND_TO_KIND_ID inline raw_ostream &operator<<(raw_ostream &OS, ASTNodeKind K) { diff --git a/clang/include/clang/AST/OpenMPClause.h b/clang/include/clang/AST/OpenMPClause.h --- a/clang/include/clang/AST/OpenMPClause.h +++ b/clang/include/clang/AST/OpenMPClause.h @@ -7758,22 +7758,22 @@ #define DISPATCH(CLASS) \ return static_cast(this)->Visit##CLASS(static_cast(S)) -#define OMP_CLAUSE_CLASS(Enum, Str, Class) \ - RetTy Visit ## Class (PTR(Class) S) { DISPATCH(Class); } -#include "llvm/Frontend/OpenMP/OMPKinds.def" +#define GEN_CLANG_CLAUSE_CLASS +#define CLAUSE_CLASS(Enum, Str, Class) \ + RetTy Visit##Class(PTR(Class) S) { DISPATCH(Class); } +#include "llvm/Frontend/OpenMP/OMP.inc" RetTy Visit(PTR(OMPClause) S) { // Top switch clause: visit each OMPClause. switch (S->getClauseKind()) { -#define OMP_CLAUSE_CLASS(Enum, Str, Class) \ +#define GEN_CLANG_CLAUSE_CLASS +#define CLAUSE_CLASS(Enum, Str, Class) \ case llvm::omp::Clause::Enum: \ return Visit##Class(static_cast(S)); -#define OMP_CLAUSE_NO_CLASS(Enum, Str) \ +#define CLAUSE_NO_CLASS(Enum, Str) \ case llvm::omp::Clause::Enum: \ break; -#include "llvm/Frontend/OpenMP/OMPKinds.def" - default: - break; +#include "llvm/Frontend/OpenMP/OMP.inc" } } // Base case, ignore it. :) @@ -7804,9 +7804,9 @@ OMPClausePrinter(raw_ostream &OS, const PrintingPolicy &Policy) : OS(OS), Policy(Policy) {} -#define OMP_CLAUSE_CLASS(Enum, Str, Class) \ - void Visit##Class(Class *S); -#include "llvm/Frontend/OpenMP/OMPKinds.def" +#define GEN_CLANG_CLAUSE_CLASS +#define CLAUSE_CLASS(Enum, Str, Class) void Visit##Class(Class *S); +#include "llvm/Frontend/OpenMP/OMP.inc" }; struct OMPTraitProperty { diff --git a/clang/include/clang/AST/RecursiveASTVisitor.h b/clang/include/clang/AST/RecursiveASTVisitor.h --- a/clang/include/clang/AST/RecursiveASTVisitor.h +++ b/clang/include/clang/AST/RecursiveASTVisitor.h @@ -488,8 +488,9 @@ bool TraverseOMPExecutableDirective(OMPExecutableDirective *S); bool TraverseOMPLoopDirective(OMPLoopDirective *S); bool TraverseOMPClause(OMPClause *C); -#define OMP_CLAUSE_CLASS(Enum, Str, Class) bool Visit##Class(Class *C); -#include "llvm/Frontend/OpenMP/OMPKinds.def" +#define GEN_CLANG_CLAUSE_CLASS +#define CLAUSE_CLASS(Enum, Str, Class) bool Visit##Class(Class *C); +#include "llvm/Frontend/OpenMP/OMP.inc" /// Process clauses with list of variables. template bool VisitOMPClauseList(T *Node); /// Process clauses with pre-initis. @@ -2949,16 +2950,15 @@ if (!C) return true; switch (C->getClauseKind()) { -#define OMP_CLAUSE_CLASS(Enum, Str, Class) \ +#define GEN_CLANG_CLAUSE_CLASS +#define CLAUSE_CLASS(Enum, Str, Class) \ case llvm::omp::Clause::Enum: \ TRY_TO(Visit##Class(static_cast(C))); \ break; -#define OMP_CLAUSE_NO_CLASS(Enum, Str) \ +#define CLAUSE_NO_CLASS(Enum, Str) \ case llvm::omp::Clause::Enum: \ break; -#include "llvm/Frontend/OpenMP/OMPKinds.def" - default: - break; +#include "llvm/Frontend/OpenMP/OMP.inc" } return true; } diff --git a/clang/lib/AST/ASTTypeTraits.cpp b/clang/lib/AST/ASTTypeTraits.cpp --- a/clang/lib/AST/ASTTypeTraits.cpp +++ b/clang/lib/AST/ASTTypeTraits.cpp @@ -21,28 +21,29 @@ using namespace clang; const ASTNodeKind::KindInfo ASTNodeKind::AllKindInfo[] = { - { NKI_None, "" }, - { NKI_None, "TemplateArgument" }, - { NKI_None, "TemplateArgumentLoc" }, - { NKI_None, "TemplateName" }, - { NKI_None, "NestedNameSpecifierLoc" }, - { NKI_None, "QualType" }, - { NKI_None, "TypeLoc" }, - { NKI_None, "CXXBaseSpecifier" }, - { NKI_None, "CXXCtorInitializer" }, - { NKI_None, "NestedNameSpecifier" }, - { NKI_None, "Decl" }, + {NKI_None, ""}, + {NKI_None, "TemplateArgument"}, + {NKI_None, "TemplateArgumentLoc"}, + {NKI_None, "TemplateName"}, + {NKI_None, "NestedNameSpecifierLoc"}, + {NKI_None, "QualType"}, + {NKI_None, "TypeLoc"}, + {NKI_None, "CXXBaseSpecifier"}, + {NKI_None, "CXXCtorInitializer"}, + {NKI_None, "NestedNameSpecifier"}, + {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" }, -#define OMP_CLAUSE_CLASS(Enum, Str, Class) {NKI_OMPClause, #Class}, -#include "llvm/Frontend/OpenMP/OMPKinds.def" + {NKI_None, "OMPClause"}, +#define GEN_CLANG_CLAUSE_CLASS +#define CLAUSE_CLASS(Enum, Str, Class) {NKI_OMPClause, #Class}, +#include "llvm/Frontend/OpenMP/OMP.inc" }; bool ASTNodeKind::isBaseOf(ASTNodeKind Other, unsigned *Distance) const { @@ -113,15 +114,14 @@ ASTNodeKind ASTNodeKind::getFromNode(const OMPClause &C) { switch (C.getClauseKind()) { -#define OMP_CLAUSE_CLASS(Enum, Str, Class) \ +#define GEN_CLANG_CLAUSE_CLASS +#define CLAUSE_CLASS(Enum, Str, Class) \ case llvm::omp::Clause::Enum: \ return ASTNodeKind(NKI_##Class); -#define OMP_CLAUSE_NO_CLASS(Enum, Str) \ +#define CLAUSE_NO_CLASS(Enum, Str) \ case llvm::omp::Clause::Enum: \ llvm_unreachable("unexpected OpenMP clause kind"); - default: - break; -#include "llvm/Frontend/OpenMP/OMPKinds.def" +#include "llvm/Frontend/OpenMP/OMP.inc" } llvm_unreachable("invalid stmt kind"); } diff --git a/clang/lib/AST/OpenMPClause.cpp b/clang/lib/AST/OpenMPClause.cpp --- a/clang/lib/AST/OpenMPClause.cpp +++ b/clang/lib/AST/OpenMPClause.cpp @@ -32,28 +32,25 @@ switch (getClauseKind()) { default: break; -#define OMP_CLAUSE_CLASS(Enum, Str, Class) \ +#define GEN_CLANG_CLAUSE_CLASS +#define CLAUSE_CLASS(Enum, Str, Class) \ case Enum: \ return static_cast(this)->children(); -#include "llvm/Frontend/OpenMP/OMPKinds.def" +#include "llvm/Frontend/OpenMP/OMP.inc" } llvm_unreachable("unknown OMPClause"); } OMPClause::child_range OMPClause::used_children() { switch (getClauseKind()) { -#define OMP_CLAUSE_CLASS(Enum, Str, Class) \ +#define GEN_CLANG_CLAUSE_CLASS +#define CLAUSE_CLASS(Enum, Str, Class) \ case Enum: \ return static_cast(this)->used_children(); -#include "llvm/Frontend/OpenMP/OMPKinds.def" - case OMPC_threadprivate: - case OMPC_uniform: - case OMPC_device_type: - case OMPC_match: - case OMPC_unknown: - break; - default: +#define CLAUSE_NO_CLASS(Enum, Str) \ + case Enum: \ break; +#include "llvm/Frontend/OpenMP/OMP.inc" } llvm_unreachable("unknown OMPClause"); } diff --git a/clang/lib/AST/StmtProfile.cpp b/clang/lib/AST/StmtProfile.cpp --- a/clang/lib/AST/StmtProfile.cpp +++ b/clang/lib/AST/StmtProfile.cpp @@ -414,8 +414,9 @@ public: OMPClauseProfiler(StmtProfiler *P) : Profiler(P) { } -#define OMP_CLAUSE_CLASS(Enum, Str, Class) void Visit##Class(const Class *C); -#include "llvm/Frontend/OpenMP/OMPKinds.def" +#define GEN_CLANG_CLAUSE_CLASS +#define CLAUSE_CLASS(Enum, Str, Class) void Visit##Class(const Class *C); +#include "llvm/Frontend/OpenMP/OMP.inc" void VistOMPClauseWithPreInit(const OMPClauseWithPreInit *C); void VistOMPClauseWithPostUpdate(const OMPClauseWithPostUpdate *C); }; diff --git a/clang/lib/ASTMatchers/Dynamic/Marshallers.h b/clang/lib/ASTMatchers/Dynamic/Marshallers.h --- a/clang/lib/ASTMatchers/Dynamic/Marshallers.h +++ b/clang/lib/ASTMatchers/Dynamic/Marshallers.h @@ -239,8 +239,9 @@ private: static Optional getClauseKind(llvm::StringRef ClauseKind) { return llvm::StringSwitch>(ClauseKind) -#define OMP_CLAUSE_CLASS(Enum, Str, Class) .Case(#Enum, llvm::omp::Clause::Enum) -#include "llvm/Frontend/OpenMP/OMPKinds.def" +#define GEN_CLANG_CLAUSE_CLASS +#define CLAUSE_CLASS(Enum, Str, Class) .Case(#Enum, llvm::omp::Clause::Enum) +#include "llvm/Frontend/OpenMP/OMP.inc" .Default(llvm::None); } diff --git a/clang/lib/ASTMatchers/Dynamic/Marshallers.cpp b/clang/lib/ASTMatchers/Dynamic/Marshallers.cpp --- a/clang/lib/ASTMatchers/Dynamic/Marshallers.cpp +++ b/clang/lib/ASTMatchers/Dynamic/Marshallers.cpp @@ -89,8 +89,9 @@ clang::ast_matchers::dynamic::internal::ArgTypeTraits< clang::OpenMPClauseKind>::getBestGuess(const VariantValue &Value) { static constexpr llvm::StringRef Allowed[] = { -#define OMP_CLAUSE_CLASS(Enum, Str, Class) #Enum, -#include "llvm/Frontend/OpenMP/OMPKinds.def" +#define GEN_CLANG_CLAUSE_CLASS +#define CLAUSE_CLASS(Enum, Str, Class) #Enum, +#include "llvm/Frontend/OpenMP/OMP.inc" }; if (Value.isString()) return ::getBestGuess(Value.getString(), llvm::makeArrayRef(Allowed), diff --git a/clang/lib/Sema/TreeTransform.h b/clang/lib/Sema/TreeTransform.h --- a/clang/lib/Sema/TreeTransform.h +++ b/clang/lib/Sema/TreeTransform.h @@ -731,10 +731,11 @@ #define ABSTRACT_STMT(Stmt) #include "clang/AST/StmtNodes.inc" -#define OMP_CLAUSE_CLASS(Enum, Str, Class) \ - LLVM_ATTRIBUTE_NOINLINE \ - OMPClause *Transform ## Class(Class *S); -#include "llvm/Frontend/OpenMP/OMPKinds.def" +#define GEN_CLANG_CLAUSE_CLASS +#define CLAUSE_CLASS(Enum, Str, Class) \ + LLVM_ATTRIBUTE_NOINLINE \ + OMPClause *Transform##Class(Class *S); +#include "llvm/Frontend/OpenMP/OMP.inc" /// Build a new qualified type given its unqualified type and type location. /// @@ -3691,10 +3692,11 @@ switch (S->getClauseKind()) { default: break; // Transform individual clause nodes -#define OMP_CLAUSE_CLASS(Enum, Str, Class) \ +#define GEN_CLANG_CLAUSE_CLASS +#define CLAUSE_CLASS(Enum, Str, Class) \ case Enum: \ - return getDerived().Transform ## Class(cast(S)); -#include "llvm/Frontend/OpenMP/OMPKinds.def" + return getDerived().Transform##Class(cast(S)); +#include "llvm/Frontend/OpenMP/OMP.inc" } return S; diff --git a/clang/lib/Serialization/ASTReader.cpp b/clang/lib/Serialization/ASTReader.cpp --- a/clang/lib/Serialization/ASTReader.cpp +++ b/clang/lib/Serialization/ASTReader.cpp @@ -11819,9 +11819,9 @@ public: OMPClauseReader(ASTRecordReader &Record) : Record(Record), Context(Record.getContext()) {} - -#define OMP_CLAUSE_CLASS(Enum, Str, Class) void Visit##Class(Class *C); -#include "llvm/Frontend/OpenMP/OMPKinds.def" +#define GEN_CLANG_CLAUSE_CLASS +#define CLAUSE_CLASS(Enum, Str, Class) void Visit##Class(Class *C); +#include "llvm/Frontend/OpenMP/OMP.inc" OMPClause *readClause(); void VisitOMPClauseWithPreInit(OMPClauseWithPreInit *C); void VisitOMPClauseWithPostUpdate(OMPClauseWithPostUpdate *C); diff --git a/clang/lib/Serialization/ASTWriter.cpp b/clang/lib/Serialization/ASTWriter.cpp --- a/clang/lib/Serialization/ASTWriter.cpp +++ b/clang/lib/Serialization/ASTWriter.cpp @@ -6210,8 +6210,9 @@ public: OMPClauseWriter(ASTRecordWriter &Record) : Record(Record) {} -#define OMP_CLAUSE_CLASS(Enum, Str, Class) void Visit##Class(Class *S); -#include "llvm/Frontend/OpenMP/OMPKinds.def" +#define GEN_CLANG_CLAUSE_CLASS +#define CLAUSE_CLASS(Enum, Str, Class) void Visit##Class(Class *S); +#include "llvm/Frontend/OpenMP/OMP.inc" void writeClause(OMPClause *C); void VisitOMPClauseWithPreInit(OMPClauseWithPreInit *C); void VisitOMPClauseWithPostUpdate(OMPClauseWithPostUpdate *C); diff --git a/clang/tools/libclang/CIndex.cpp b/clang/tools/libclang/CIndex.cpp --- a/clang/tools/libclang/CIndex.cpp +++ b/clang/tools/libclang/CIndex.cpp @@ -2174,8 +2174,9 @@ public: OMPClauseEnqueue(EnqueueVisitor *Visitor) : Visitor(Visitor) {} -#define OMP_CLAUSE_CLASS(Enum, Str, Class) void Visit##Class(const Class *C); -#include "llvm/Frontend/OpenMP/OMPKinds.def" +#define GEN_CLANG_CLAUSE_CLASS +#define CLAUSE_CLASS(Enum, Str, Class) void Visit##Class(const Class *C); +#include "llvm/Frontend/OpenMP/OMP.inc" void VisitOMPClauseWithPreInit(const OMPClauseWithPreInit *C); void VisitOMPClauseWithPostUpdate(const OMPClauseWithPostUpdate *C); }; diff --git a/flang/include/flang/Parser/dump-parse-tree.h b/flang/include/flang/Parser/dump-parse-tree.h --- a/flang/include/flang/Parser/dump-parse-tree.h +++ b/flang/include/flang/Parser/dump-parse-tree.h @@ -462,7 +462,7 @@ NODE_ENUM(OmpCancelType, Type) NODE(parser, OmpClause) #define GEN_FLANG_DUMP_PARSE_TREE_CLAUSES -#include "llvm/Frontend/OpenMP/OMP.cpp.inc" +#include "llvm/Frontend/OpenMP/OMP.inc" NODE(parser, OmpClauseList) NODE(parser, OmpCriticalDirective) NODE(parser, OmpDeclareTargetSpecifier) diff --git a/flang/include/flang/Parser/parse-tree.h b/flang/include/flang/Parser/parse-tree.h --- a/flang/include/flang/Parser/parse-tree.h +++ b/flang/include/flang/Parser/parse-tree.h @@ -3472,13 +3472,13 @@ UNION_CLASS_BOILERPLATE(OmpClause); #define GEN_FLANG_CLAUSE_PARSER_CLASSES -#include "llvm/Frontend/OpenMP/OMP.cpp.inc" +#include "llvm/Frontend/OpenMP/OMP.inc" CharBlock source; std::variant< #define GEN_FLANG_CLAUSE_PARSER_CLASSES_LIST -#include "llvm/Frontend/OpenMP/OMP.cpp.inc" +#include "llvm/Frontend/OpenMP/OMP.inc" > u; }; diff --git a/flang/lib/Parser/unparse.cpp b/flang/lib/Parser/unparse.cpp --- a/flang/lib/Parser/unparse.cpp +++ b/flang/lib/Parser/unparse.cpp @@ -2074,7 +2074,7 @@ Put(")"); } #define GEN_FLANG_CLAUSE_UNPARSE -#include "llvm/Frontend/OpenMP/OMP.cpp.inc" +#include "llvm/Frontend/OpenMP/OMP.inc" void Unparse(const OmpLoopDirective &x) { switch (x.v) { case llvm::omp::Directive::OMPD_distribute: diff --git a/flang/lib/Semantics/check-omp-structure.h b/flang/lib/Semantics/check-omp-structure.h --- a/flang/lib/Semantics/check-omp-structure.h +++ b/flang/lib/Semantics/check-omp-structure.h @@ -27,7 +27,7 @@ Fortran::common::EnumSet; #define GEN_FLANG_DIRECTIVE_CLAUSE_SETS -#include "llvm/Frontend/OpenMP/OMP.cpp.inc" +#include "llvm/Frontend/OpenMP/OMP.inc" namespace llvm { namespace omp { @@ -85,7 +85,7 @@ OmpStructureChecker(SemanticsContext &context) : DirectiveStructureChecker(context, #define GEN_FLANG_DIRECTIVE_CLAUSE_MAP -#include "llvm/Frontend/OpenMP/OMP.cpp.inc" +#include "llvm/Frontend/OpenMP/OMP.inc" ) { } diff --git a/llvm/include/llvm/Frontend/OpenMP/CMakeLists.txt b/llvm/include/llvm/Frontend/OpenMP/CMakeLists.txt --- a/llvm/include/llvm/Frontend/OpenMP/CMakeLists.txt +++ b/llvm/include/llvm/Frontend/OpenMP/CMakeLists.txt @@ -1,4 +1,4 @@ set(LLVM_TARGET_DEFINITIONS OMP.td) tablegen(LLVM OMP.h.inc --gen-directive-decl) -tablegen(LLVM OMP.cpp.inc --gen-directive-gen) +tablegen(LLVM OMP.inc --gen-directive-gen) add_public_tablegen_target(omp_gen) diff --git a/llvm/include/llvm/Frontend/OpenMP/OMPKinds.def b/llvm/include/llvm/Frontend/OpenMP/OMPKinds.def --- a/llvm/include/llvm/Frontend/OpenMP/OMPKinds.def +++ b/llvm/include/llvm/Frontend/OpenMP/OMPKinds.def @@ -7,130 +7,16 @@ //===----------------------------------------------------------------------===// /// \file /// -/// This file defines the list of supported OpenMP directives, clauses, runtime +/// This file defines the list of supported OpenMP 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 and combined directives +/// OpenMP Directives, combined directives and Clauses /// - 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 /// ///{ diff --git a/llvm/include/llvm/TableGen/DirectiveEmitter.h b/llvm/include/llvm/TableGen/DirectiveEmitter.h --- a/llvm/include/llvm/TableGen/DirectiveEmitter.h +++ b/llvm/include/llvm/TableGen/DirectiveEmitter.h @@ -182,7 +182,7 @@ return Def->getValueAsString("defaultValue"); } - bool isImplict() const { return Def->getValueAsBit("isImplicit"); } + bool isImplicit() const { return Def->getValueAsBit("isImplicit"); } }; // Wrapper class that contains VersionedClause's information defined in diff --git a/llvm/test/TableGen/directive2.td b/llvm/test/TableGen/directive2.td --- a/llvm/test/TableGen/directive2.td +++ b/llvm/test/TableGen/directive2.td @@ -23,10 +23,15 @@ 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 = [ @@ -53,9 +58,10 @@ // 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 = 3; +// CHECK-NEXT: static constexpr std::size_t Clause_enumSize = 4; // CHECK-EMPTY: // CHECK-NEXT: // Enumeration helper functions // CHECK-NEXT: Directive getTdlDirectiveKind(llvm::StringRef Str); @@ -101,6 +107,7 @@ // 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: @@ -112,6 +119,8 @@ // 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: } @@ -183,6 +192,7 @@ // GEN-NEXT: EMPTY_CLASS(Clausea); // GEN-NEXT: WRAPPER_CLASS(Clauseb, std::list); // GEN-NEXT: WRAPPER_CLASS(Clausec, std::optional); +// GEN-NEXT: EMPTY_CLASS(Claused); // GEN-EMPTY: // GEN-NEXT: #endif // GEN_FLANG_CLAUSE_PARSER_CLASSES // GEN-EMPTY: @@ -192,6 +202,7 @@ // 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: @@ -201,6 +212,7 @@ // 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: @@ -223,5 +235,47 @@ // 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 + diff --git a/llvm/utils/TableGen/DirectiveEmitter.cpp b/llvm/utils/TableGen/DirectiveEmitter.cpp --- a/llvm/utils/TableGen/DirectiveEmitter.cpp +++ b/llvm/utils/TableGen/DirectiveEmitter.cpp @@ -645,6 +645,72 @@ 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) { @@ -653,6 +719,8 @@ return; EmitDirectivesFlangImpl(DirLang, OS); + + GenerateClauseClassMacro(DirLang, OS); } // Generate the implemenation for the enumeration in the directive