maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity

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

This reverts commit a7b2847216.

failing buildbot on warnings
This commit is contained in:
clementval 2020-12-10 10:34:59 -05:00
parent d2a7b83c5c
commit 456c885df3
17 changed files with 182 additions and 207 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
clang/include/clang/AST/ASTFwd.h
View File

@ -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

10
clang/include/clang/AST/ASTTypeTraits.h
View File

@ -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 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) {

20
clang/include/clang/AST/OpenMPClause.h
View File

@ -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 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<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 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 {

12
clang/include/clang/AST/RecursiveASTVisitor.h
View File

@ -488,9 +488,8 @@ private:
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 <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 CLAUSE_CLASS(Enum, Str, Class) \
#define OMP_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;
}

40
clang/lib/AST/ASTTypeTraits.cpp
View File

@ -21,29 +21,28 @@
using namespace clang;
const ASTNodeKind::KindInfo ASTNodeKind::AllKindInfo[] = {
{NKI_None, "<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, "<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");
}

10
clang/lib/AST/OpenMPClause.cpp
View File

@ -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<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 CLAUSE_CLASS(Enum, Str, Class) \
#define OMP_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:

5
clang/lib/AST/StmtProfile.cpp
View File

@ -414,9 +414,8 @@ class OMPClauseProfiler : public ConstOMPClauseVisitor<OMPClauseProfiler> {
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);
};

5
clang/lib/ASTMatchers/Dynamic/Marshallers.cpp
View File

@ -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 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),

5
clang/lib/ASTMatchers/Dynamic/Marshallers.h
View File

@ -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 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);
}

16
clang/lib/Sema/TreeTransform.h
View File

@ -731,11 +731,10 @@ public:
#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<Derived>::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<Class>(S));
#include "llvm/Frontend/OpenMP/OMP.cpp.inc"
return getDerived().Transform ## Class(cast<Class>(S));
#include "llvm/Frontend/OpenMP/OMPKinds.def"
}
return S;

6
clang/lib/Serialization/ASTReader.cpp
View File

@ -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);
#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);

5
clang/lib/Serialization/ASTWriter.cpp
View File

@ -6210,9 +6210,8 @@ class OMPClauseWriter : public OMPClauseVisitor<OMPClauseWriter> {
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);

5
clang/tools/libclang/CIndex.cpp
View File

@ -2174,9 +2174,8 @@ class OMPClauseEnqueue : public ConstOMPClauseVisitor<OMPClauseEnqueue> {
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);
};

118
llvm/include/llvm/Frontend/OpenMP/OMPKinds.def
View File

@ -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
///
///{

2
llvm/include/llvm/TableGen/DirectiveEmitter.h
View File

@ -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

56
llvm/test/TableGen/directive2.td
View File

@ -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

68
llvm/utils/TableGen/DirectiveEmitter.cpp
View File

@ -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