diff --git a/clang/include/clang/AST/ASTFwd.h b/clang/include/clang/AST/ASTFwd.h index 6eceb526ca4c08..65319a19728b5f 100644 --- a/clang/include/clang/AST/ASTFwd.h +++ b/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 CLAUSE_CLASS(Enum, Str, Class) class Class; -#include "llvm/Frontend/OpenMP/OMP.cpp.inc" +#define OMP_CLAUSE_CLASS(Enum, Str, Class) class Class; +#include "llvm/Frontend/OpenMP/OMPKinds.def" + } // end namespace clang diff --git a/clang/include/clang/AST/ASTTypeTraits.h b/clang/include/clang/AST/ASTTypeTraits.h index 92123ed2a32ad2..ea3da8d90c5b9d 100644 --- a/clang/include/clang/AST/ASTTypeTraits.h +++ b/clang/include/clang/AST/ASTTypeTraits.h @@ -147,9 +147,8 @@ class ASTNodeKind { #define TYPE(DERIVED, BASE) NKI_##DERIVED##Type, #include "clang/AST/TypeNodes.inc" NKI_OMPClause, -#define GEN_CLANG_CLAUSE_CLASS -#define CLAUSE_CLASS(Enum, Str, Class) NKI_##Class, -#include "llvm/Frontend/OpenMP/OMP.cpp.inc" +#define OMP_CLAUSE_CLASS(Enum, Str, Class) NKI_##Class, +#include "llvm/Frontend/OpenMP/OMPKinds.def" 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 CLAUSE_CLASS(Enum, Str, Class) KIND_TO_KIND_ID(Class) -#include "llvm/Frontend/OpenMP/OMP.cpp.inc" +#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) { diff --git a/clang/include/clang/AST/OpenMPClause.h b/clang/include/clang/AST/OpenMPClause.h index 57ba4fa5510fd0..cc6d3a93ba09ca 100644 --- a/clang/include/clang/AST/OpenMPClause.h +++ b/clang/include/clang/AST/OpenMPClause.h @@ -7758,22 +7758,20 @@ class OMPClauseVisitorBase { #define DISPATCH(CLASS) \ return static_cast(this)->Visit##CLASS(static_cast(S)) -#define GEN_CLANG_CLAUSE_CLASS -#define CLAUSE_CLASS(Enum, Str, Class) \ - RetTy Visit##Class(PTR(Class) S) { DISPATCH(Class); } -#include "llvm/Frontend/OpenMP/OMP.cpp.inc" +#define OMP_CLAUSE_CLASS(Enum, Str, Class) \ + RetTy Visit ## Class (PTR(Class) S) { DISPATCH(Class); } +#include "llvm/Frontend/OpenMP/OMPKinds.def" RetTy Visit(PTR(OMPClause) S) { // Top switch clause: visit each OMPClause. switch (S->getClauseKind()) { -#define GEN_CLANG_CLAUSE_CLASS -#define CLAUSE_CLASS(Enum, Str, Class) \ +#define OMP_CLAUSE_CLASS(Enum, Str, Class) \ case llvm::omp::Clause::Enum: \ return Visit##Class(static_cast(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 @@ class OMPClausePrinter final : public OMPClauseVisitor { OMPClausePrinter(raw_ostream &OS, const PrintingPolicy &Policy) : OS(OS), Policy(Policy) {} -#define GEN_CLANG_CLAUSE_CLASS -#define CLAUSE_CLASS(Enum, Str, Class) void Visit##Class(Class *S); -#include "llvm/Frontend/OpenMP/OMP.cpp.inc" +#define OMP_CLAUSE_CLASS(Enum, Str, Class) \ + void Visit##Class(Class *S); +#include "llvm/Frontend/OpenMP/OMPKinds.def" }; struct OMPTraitProperty { diff --git a/clang/include/clang/AST/RecursiveASTVisitor.h b/clang/include/clang/AST/RecursiveASTVisitor.h index 206651332758ad..612e60cf4df1cd 100644 --- a/clang/include/clang/AST/RecursiveASTVisitor.h +++ b/clang/include/clang/AST/RecursiveASTVisitor.h @@ -488,9 +488,8 @@ template class RecursiveASTVisitor { bool TraverseOMPExecutableDirective(OMPExecutableDirective *S); bool TraverseOMPLoopDirective(OMPLoopDirective *S); bool TraverseOMPClause(OMPClause *C); -#define GEN_CLANG_CLAUSE_CLASS -#define CLAUSE_CLASS(Enum, Str, Class) bool Visit##Class(Class *C); -#include "llvm/Frontend/OpenMP/OMP.cpp.inc" +#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 bool VisitOMPClauseList(T *Node); /// Process clauses with pre-initis. @@ -2950,15 +2949,14 @@ bool RecursiveASTVisitor::TraverseOMPClause(OMPClause *C) { if (!C) return true; switch (C->getClauseKind()) { -#define GEN_CLANG_CLAUSE_CLASS -#define CLAUSE_CLASS(Enum, Str, Class) \ +#define OMP_CLAUSE_CLASS(Enum, Str, Class) \ case llvm::omp::Clause::Enum: \ TRY_TO(Visit##Class(static_cast(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; } diff --git a/clang/lib/AST/ASTTypeTraits.cpp b/clang/lib/AST/ASTTypeTraits.cpp index 8c2b5a9fa29d54..ce8a321a691f4f 100644 --- a/clang/lib/AST/ASTTypeTraits.cpp +++ b/clang/lib/AST/ASTTypeTraits.cpp @@ -21,29 +21,28 @@ 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 GEN_CLANG_CLAUSE_CLASS -#define CLAUSE_CLASS(Enum, Str, Class) {NKI_OMPClause, #Class}, -#include "llvm/Frontend/OpenMP/OMP.cpp.inc" + { NKI_None, "OMPClause" }, +#define OMP_CLAUSE_CLASS(Enum, Str, Class) {NKI_OMPClause, #Class}, +#include "llvm/Frontend/OpenMP/OMPKinds.def" }; 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 CLAUSE_CLASS(Enum, Str, Class) \ +#define OMP_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"); } diff --git a/clang/lib/AST/OpenMPClause.cpp b/clang/lib/AST/OpenMPClause.cpp index 2d37a559593f8c..6590738268c60d 100644 --- a/clang/lib/AST/OpenMPClause.cpp +++ b/clang/lib/AST/OpenMPClause.cpp @@ -32,22 +32,20 @@ OMPClause::child_range OMPClause::children() { switch (getClauseKind()) { default: break; -#define GEN_CLANG_CLAUSE_CLASS -#define CLAUSE_CLASS(Enum, Str, Class) \ +#define OMP_CLAUSE_CLASS(Enum, Str, Class) \ case Enum: \ return static_cast(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 CLAUSE_CLASS(Enum, Str, Class) \ +#define OMP_CLAUSE_CLASS(Enum, Str, Class) \ case Enum: \ return static_cast(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: diff --git a/clang/lib/AST/StmtProfile.cpp b/clang/lib/AST/StmtProfile.cpp index 789964a6db8812..bf3b43b816f17b 100644 --- a/clang/lib/AST/StmtProfile.cpp +++ b/clang/lib/AST/StmtProfile.cpp @@ -414,9 +414,8 @@ class OMPClauseProfiler : public ConstOMPClauseVisitor { public: OMPClauseProfiler(StmtProfiler *P) : Profiler(P) { } -#define GEN_CLANG_CLAUSE_CLASS -#define CLAUSE_CLASS(Enum, Str, Class) void Visit##Class(const Class *C); -#include "llvm/Frontend/OpenMP/OMP.cpp.inc" +#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); }; diff --git a/clang/lib/ASTMatchers/Dynamic/Marshallers.cpp b/clang/lib/ASTMatchers/Dynamic/Marshallers.cpp index 40941df853ddb0..33fb7a92955bbe 100644 --- a/clang/lib/ASTMatchers/Dynamic/Marshallers.cpp +++ b/clang/lib/ASTMatchers/Dynamic/Marshallers.cpp @@ -89,9 +89,8 @@ llvm::Optional clang::ast_matchers::dynamic::internal::ArgTypeTraits< clang::OpenMPClauseKind>::getBestGuess(const VariantValue &Value) { static constexpr llvm::StringRef Allowed[] = { -#define GEN_CLANG_CLAUSE_CLASS -#define CLAUSE_CLASS(Enum, Str, Class) #Enum, -#include "llvm/Frontend/OpenMP/OMP.cpp.inc" +#define OMP_CLAUSE_CLASS(Enum, Str, Class) #Enum, +#include "llvm/Frontend/OpenMP/OMPKinds.def" }; if (Value.isString()) return ::getBestGuess(Value.getString(), llvm::makeArrayRef(Allowed), diff --git a/clang/lib/ASTMatchers/Dynamic/Marshallers.h b/clang/lib/ASTMatchers/Dynamic/Marshallers.h index 94f44b3701f23c..9758d36b0dc63a 100644 --- a/clang/lib/ASTMatchers/Dynamic/Marshallers.h +++ b/clang/lib/ASTMatchers/Dynamic/Marshallers.h @@ -239,9 +239,8 @@ template <> struct ArgTypeTraits { private: static Optional getClauseKind(llvm::StringRef ClauseKind) { return llvm::StringSwitch>(ClauseKind) -#define GEN_CLANG_CLAUSE_CLASS -#define CLAUSE_CLASS(Enum, Str, Class) .Case(#Enum, llvm::omp::Clause::Enum) -#include "llvm/Frontend/OpenMP/OMP.cpp.inc" +#define OMP_CLAUSE_CLASS(Enum, Str, Class) .Case(#Enum, llvm::omp::Clause::Enum) +#include "llvm/Frontend/OpenMP/OMPKinds.def" .Default(llvm::None); } diff --git a/clang/lib/Sema/TreeTransform.h b/clang/lib/Sema/TreeTransform.h index 275b1800735d9b..27f0ca91aede04 100644 --- a/clang/lib/Sema/TreeTransform.h +++ b/clang/lib/Sema/TreeTransform.h @@ -731,11 +731,10 @@ class TreeTransform { #define ABSTRACT_STMT(Stmt) #include "clang/AST/StmtNodes.inc" -#define GEN_CLANG_CLAUSE_CLASS -#define CLAUSE_CLASS(Enum, Str, Class) \ - LLVM_ATTRIBUTE_NOINLINE \ - OMPClause *Transform##Class(Class *S); -#include "llvm/Frontend/OpenMP/OMP.cpp.inc" +#define OMP_CLAUSE_CLASS(Enum, Str, Class) \ + LLVM_ATTRIBUTE_NOINLINE \ + OMPClause *Transform ## Class(Class *S); +#include "llvm/Frontend/OpenMP/OMPKinds.def" /// Build a new qualified type given its unqualified type and type location. /// @@ -3692,11 +3691,10 @@ OMPClause *TreeTransform::TransformOMPClause(OMPClause *S) { switch (S->getClauseKind()) { default: break; // Transform individual clause nodes -#define GEN_CLANG_CLAUSE_CLASS -#define CLAUSE_CLASS(Enum, Str, Class) \ +#define OMP_CLAUSE_CLASS(Enum, Str, Class) \ case Enum: \ - return getDerived().Transform##Class(cast(S)); -#include "llvm/Frontend/OpenMP/OMP.cpp.inc" + return getDerived().Transform ## Class(cast(S)); +#include "llvm/Frontend/OpenMP/OMPKinds.def" } return S; diff --git a/clang/lib/Serialization/ASTReader.cpp b/clang/lib/Serialization/ASTReader.cpp index f80e435fc9be03..c2ddd8e3df70e4 100644 --- a/clang/lib/Serialization/ASTReader.cpp +++ b/clang/lib/Serialization/ASTReader.cpp @@ -11819,9 +11819,9 @@ class OMPClauseReader : public OMPClauseVisitor { 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); -#include "llvm/Frontend/OpenMP/OMP.cpp.inc" + +#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); diff --git a/clang/lib/Serialization/ASTWriter.cpp b/clang/lib/Serialization/ASTWriter.cpp index c628650714b4f8..4d1e6bfcb14500 100644 --- a/clang/lib/Serialization/ASTWriter.cpp +++ b/clang/lib/Serialization/ASTWriter.cpp @@ -6210,9 +6210,8 @@ class OMPClauseWriter : public OMPClauseVisitor { public: OMPClauseWriter(ASTRecordWriter &Record) : Record(Record) {} -#define GEN_CLANG_CLAUSE_CLASS -#define CLAUSE_CLASS(Enum, Str, Class) void Visit##Class(Class *S); -#include "llvm/Frontend/OpenMP/OMP.cpp.inc" +#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); diff --git a/clang/tools/libclang/CIndex.cpp b/clang/tools/libclang/CIndex.cpp index debe10faa116be..aa888a38004800 100644 --- a/clang/tools/libclang/CIndex.cpp +++ b/clang/tools/libclang/CIndex.cpp @@ -2174,9 +2174,8 @@ class OMPClauseEnqueue : public ConstOMPClauseVisitor { public: OMPClauseEnqueue(EnqueueVisitor *Visitor) : Visitor(Visitor) {} -#define GEN_CLANG_CLAUSE_CLASS -#define CLAUSE_CLASS(Enum, Str, Class) void Visit##Class(const Class *C); -#include "llvm/Frontend/OpenMP/OMP.cpp.inc" +#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); }; diff --git a/llvm/include/llvm/Frontend/OpenMP/OMPKinds.def b/llvm/include/llvm/Frontend/OpenMP/OMPKinds.def index 5440dff9f5caae..947b0c8d5ef226 100644 --- a/llvm/include/llvm/Frontend/OpenMP/OMPKinds.def +++ b/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 /// ///{ diff --git a/llvm/include/llvm/TableGen/DirectiveEmitter.h b/llvm/include/llvm/TableGen/DirectiveEmitter.h index 41258ade8963e7..8b0b5bc07dd905 100644 --- a/llvm/include/llvm/TableGen/DirectiveEmitter.h +++ b/llvm/include/llvm/TableGen/DirectiveEmitter.h @@ -182,7 +182,7 @@ class Clause : public BaseRecord { 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 diff --git a/llvm/test/TableGen/directive2.td b/llvm/test/TableGen/directive2.td index f7b1e7365b1e34..bf5ec02d5f0c19 100644 --- a/llvm/test/TableGen/directive2.td +++ b/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); // GEN-NEXT: WRAPPER_CLASS(Clausec, std::optional); -// 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 - diff --git a/llvm/utils/TableGen/DirectiveEmitter.cpp b/llvm/utils/TableGen/DirectiveEmitter.cpp index ff6050b07f52b5..93b988e3c39f40 100644 --- a/llvm/utils/TableGen/DirectiveEmitter.cpp +++ b/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