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

[OpenMP][NFC] Move and simplify directive -> allowed clause mapping 

Move the listing of allowed clauses per OpenMP directive to the new
macro file in `llvm/Frontend/OpenMP`. Also, use a single generic macro
that specifies the directive and one allowed clause explicitly instead
of a dedicated macro per directive.

We save 800 loc and boilerplate for all new directives/clauses with no
functional change. We also need to include the macro file only once and
not once per directive.

Depends on D77112.

Reviewed By: JonChesterfield

Differential Revision: https://reviews.llvm.org/D77113
This commit is contained in:
Johannes Doerfert 2020-03-30 00:57:28 -05:00
parent 8ea07f62a6
commit 931c0cd713
18 changed files with 762 additions and 1532 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
clang/include/clang/ASTMatchers/ASTMatchers.h
View File

@ -7119,7 +7119,7 @@ AST_MATCHER(OMPDefaultClause, isSharedKind) {
/// ``isAllowedToContainClauseKind("OMPC_default").``
AST_MATCHER_P(OMPExecutableDirective, isAllowedToContainClauseKind,
OpenMPClauseKind, CKind) {
return isAllowedClauseForDirective(
return llvm::omp::isAllowedClauseForDirective(
Node.getDirectiveKind(), CKind,
Finder->getASTContext().getLangOpts().OpenMP);
}

951
clang/include/clang/Basic/OpenMPKinds.def
View File

File diff suppressed because it is too large Load Diff

4
clang/include/clang/Basic/OpenMPKinds.h
View File

@ -173,10 +173,6 @@ enum OpenMPReductionClauseModifier {
unsigned getOpenMPSimpleClauseType(OpenMPClauseKind Kind, llvm::StringRef Str);
const char *getOpenMPSimpleClauseTypeName(OpenMPClauseKind Kind, unsigned Type);
bool isAllowedClauseForDirective(OpenMPDirectiveKind DKind,
OpenMPClauseKind CKind,
unsigned OpenMPVersion);
/// Checks if the specified directive is a directive with an associated
/// loop construct.
/// \param DKind Specified directive.

5
clang/lib/ASTMatchers/Dynamic/CMakeLists.txt
View File

@ -1,4 +1,7 @@
set(LLVM_LINK_COMPONENTS support)
set(LLVM_LINK_COMPONENTS
FrontendOpenMP
Support
)
# The registry source file ends up generating a lot of sections for each
# matcher. Each matcher appears to get a vtable and several methods. Each

575
clang/lib/Basic/OpenMPKinds.cpp
View File

@ -425,581 +425,6 @@ const char *clang::getOpenMPSimpleClauseTypeName(OpenMPClauseKind Kind,
llvm_unreachable("Invalid OpenMP simple clause kind");
}
bool clang::isAllowedClauseForDirective(OpenMPDirectiveKind DKind,
OpenMPClauseKind CKind,
unsigned OpenMPVersion) {
assert(unsigned(DKind) <= unsigned(OMPD_unknown));
assert(CKind <= OMPC_unknown);
// Nontemporal clause is not supported in OpenMP < 5.0.
if (OpenMPVersion < 50 && CKind == OMPC_nontemporal)
return false;
// Order clause is not supported in OpenMP < 5.0.
if (OpenMPVersion < 50 && CKind == OMPC_order)
return false;
switch (DKind) {
case OMPD_parallel:
switch (CKind) {
#define OPENMP_PARALLEL_CLAUSE(Name) \
case OMPC_##Name: \
return true;
#include "clang/Basic/OpenMPKinds.def"
default:
break;
}
break;
case OMPD_simd:
if (OpenMPVersion < 50 && CKind == OMPC_if)
return false;
switch (CKind) {
#define OPENMP_SIMD_CLAUSE(Name) \
case OMPC_##Name: \
return true;
#include "clang/Basic/OpenMPKinds.def"
default:
break;
}
break;
case OMPD_for:
switch (CKind) {
#define OPENMP_FOR_CLAUSE(Name) \
case OMPC_##Name: \
return true;
#include "clang/Basic/OpenMPKinds.def"
default:
break;
}
break;
case OMPD_for_simd:
if (OpenMPVersion < 50 && CKind == OMPC_if)
return false;
switch (CKind) {
#define OPENMP_FOR_SIMD_CLAUSE(Name) \
case OMPC_##Name: \
return true;
#include "clang/Basic/OpenMPKinds.def"
default:
break;
}
break;
case OMPD_sections:
switch (CKind) {
#define OPENMP_SECTIONS_CLAUSE(Name) \
case OMPC_##Name: \
return true;
#include "clang/Basic/OpenMPKinds.def"
default:
break;
}
break;
case OMPD_single:
switch (CKind) {
#define OPENMP_SINGLE_CLAUSE(Name) \
case OMPC_##Name: \
return true;
#include "clang/Basic/OpenMPKinds.def"
default:
break;
}
break;
case OMPD_parallel_for:
switch (CKind) {
#define OPENMP_PARALLEL_FOR_CLAUSE(Name) \
case OMPC_##Name: \
return true;
#include "clang/Basic/OpenMPKinds.def"
default:
break;
}
break;
case OMPD_parallel_for_simd:
switch (CKind) {
#define OPENMP_PARALLEL_FOR_SIMD_CLAUSE(Name) \
case OMPC_##Name: \
return true;
#include "clang/Basic/OpenMPKinds.def"
default:
break;
}
break;
case OMPD_parallel_master:
switch (CKind) {
#define OPENMP_PARALLEL_MASTER_CLAUSE(Name) \
case OMPC_##Name: \
return true;
#include "clang/Basic/OpenMPKinds.def"
default:
break;
}
break;
case OMPD_parallel_sections:
switch (CKind) {
#define OPENMP_PARALLEL_SECTIONS_CLAUSE(Name) \
case OMPC_##Name: \
return true;
#include "clang/Basic/OpenMPKinds.def"
default:
break;
}
break;
case OMPD_task:
if (OpenMPVersion < 50 && CKind == OMPC_detach)
return false;
switch (CKind) {
#define OPENMP_TASK_CLAUSE(Name) \
case OMPC_##Name: \
return true;
#include "clang/Basic/OpenMPKinds.def"
default:
break;
}
break;
case OMPD_flush:
if (CKind == OMPC_flush)
return true;
if (OpenMPVersion < 50)
return false;
switch (CKind) {
#define OPENMP_FLUSH_CLAUSE(Name) \
case OMPC_##Name: \
return true;
#include "clang/Basic/OpenMPKinds.def"
default:
break;
}
break;
case OMPD_depobj:
if (OpenMPVersion < 50)
return false;
switch (CKind) {
#define OPENMP_DEPOBJ_CLAUSE(Name) \
case OMPC_##Name: \
return true;
#include "clang/Basic/OpenMPKinds.def"
case OMPC_depobj:
return true;
default:
break;
}
break;
case OMPD_scan:
if (OpenMPVersion < 50)
return false;
switch (CKind) {
#define OPENMP_SCAN_CLAUSE(Name) \
case OMPC_##Name: \
return true;
#include "clang/Basic/OpenMPKinds.def"
default:
break;
}
break;
case OMPD_atomic:
if (OpenMPVersion < 50 &&
(CKind == OMPC_acq_rel || CKind == OMPC_acquire ||
CKind == OMPC_release || CKind == OMPC_relaxed || CKind == OMPC_hint))
return false;
switch (CKind) {
#define OPENMP_ATOMIC_CLAUSE(Name) \
case OMPC_##Name: \
return true;
#include "clang/Basic/OpenMPKinds.def"
default:
break;
}
break;
case OMPD_target:
switch (CKind) {
#define OPENMP_TARGET_CLAUSE(Name) \
case OMPC_##Name: \
return true;
#include "clang/Basic/OpenMPKinds.def"
default:
break;
}
break;
case OMPD_requires:
switch (CKind) {
#define OPENMP_REQUIRES_CLAUSE(Name) \
case OMPC_##Name: \
return true;
#include "clang/Basic/OpenMPKinds.def"
default:
break;
}
break;
case OMPD_target_data:
switch (CKind) {
#define OPENMP_TARGET_DATA_CLAUSE(Name) \
case OMPC_##Name: \
return true;
#include "clang/Basic/OpenMPKinds.def"
default:
break;
}
break;
case OMPD_target_enter_data:
switch (CKind) {
#define OPENMP_TARGET_ENTER_DATA_CLAUSE(Name) \
case OMPC_##Name: \
return true;
#include "clang/Basic/OpenMPKinds.def"
default:
break;
}
break;
case OMPD_target_exit_data:
switch (CKind) {
#define OPENMP_TARGET_EXIT_DATA_CLAUSE(Name) \
case OMPC_##Name: \
return true;
#include "clang/Basic/OpenMPKinds.def"
default:
break;
}
break;
case OMPD_target_parallel:
switch (CKind) {
#define OPENMP_TARGET_PARALLEL_CLAUSE(Name) \
case OMPC_##Name: \
return true;
#include "clang/Basic/OpenMPKinds.def"
default:
break;
}
break;
case OMPD_target_parallel_for:
switch (CKind) {
#define OPENMP_TARGET_PARALLEL_FOR_CLAUSE(Name) \
case OMPC_##Name: \
return true;
#include "clang/Basic/OpenMPKinds.def"
default:
break;
}
break;
case OMPD_target_update:
switch (CKind) {
#define OPENMP_TARGET_UPDATE_CLAUSE(Name) \
case OMPC_##Name: \
return true;
#include "clang/Basic/OpenMPKinds.def"
default:
break;
}
break;
case OMPD_teams:
switch (CKind) {
#define OPENMP_TEAMS_CLAUSE(Name) \
case OMPC_##Name: \
return true;
#include "clang/Basic/OpenMPKinds.def"
default:
break;
}
break;
case OMPD_cancel:
switch (CKind) {
#define OPENMP_CANCEL_CLAUSE(Name) \
case OMPC_##Name: \
return true;
#include "clang/Basic/OpenMPKinds.def"
default:
break;
}
break;
case OMPD_ordered:
switch (CKind) {
#define OPENMP_ORDERED_CLAUSE(Name) \
case OMPC_##Name: \
return true;
#include "clang/Basic/OpenMPKinds.def"
default:
break;
}
break;
case OMPD_taskloop:
switch (CKind) {
#define OPENMP_TASKLOOP_CLAUSE(Name) \
case OMPC_##Name: \
return true;
#include "clang/Basic/OpenMPKinds.def"
default:
break;
}
break;
case OMPD_taskloop_simd:
switch (CKind) {
#define OPENMP_TASKLOOP_SIMD_CLAUSE(Name) \
case OMPC_##Name: \
return true;
#include "clang/Basic/OpenMPKinds.def"
default:
break;
}
break;
case OMPD_master_taskloop:
switch (CKind) {
#define OPENMP_MASTER_TASKLOOP_CLAUSE(Name) \
case OMPC_##Name: \
return true;
#include "clang/Basic/OpenMPKinds.def"
default:
break;
}
break;
case OMPD_master_taskloop_simd:
switch (CKind) {
#define OPENMP_MASTER_TASKLOOP_SIMD_CLAUSE(Name) \
case OMPC_##Name: \
return true;
#include "clang/Basic/OpenMPKinds.def"
default:
break;
}
break;
case OMPD_parallel_master_taskloop:
switch (CKind) {
#define OPENMP_PARALLEL_MASTER_TASKLOOP_CLAUSE(Name) \
case OMPC_##Name: \
return true;
#include "clang/Basic/OpenMPKinds.def"
default:
break;
}
break;
case OMPD_parallel_master_taskloop_simd:
switch (CKind) {
#define OPENMP_PARALLEL_MASTER_TASKLOOP_SIMD_CLAUSE(Name) \
case OMPC_##Name: \
return true;
#include "clang/Basic/OpenMPKinds.def"
default:
break;
}
break;
case OMPD_critical:
switch (CKind) {
#define OPENMP_CRITICAL_CLAUSE(Name) \
case OMPC_##Name: \
return true;
#include "clang/Basic/OpenMPKinds.def"
default:
break;
}
break;
case OMPD_distribute:
switch (CKind) {
#define OPENMP_DISTRIBUTE_CLAUSE(Name) \
case OMPC_##Name: \
return true;
#include "clang/Basic/OpenMPKinds.def"
default:
break;
}
break;
case OMPD_distribute_parallel_for:
switch (CKind) {
#define OPENMP_DISTRIBUTE_PARALLEL_FOR_CLAUSE(Name) \
case OMPC_##Name: \
return true;
#include "clang/Basic/OpenMPKinds.def"
default:
break;
}
break;
case OMPD_distribute_parallel_for_simd:
switch (CKind) {
#define OPENMP_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(Name) \
case OMPC_##Name: \
return true;
#include "clang/Basic/OpenMPKinds.def"
default:
break;
}
break;
case OMPD_distribute_simd:
if (OpenMPVersion < 50 && CKind == OMPC_if)
return false;
switch (CKind) {
#define OPENMP_DISTRIBUTE_SIMD_CLAUSE(Name) \
case OMPC_##Name: \
return true;
#include "clang/Basic/OpenMPKinds.def"
default:
break;
}
break;
case OMPD_target_parallel_for_simd:
switch (CKind) {
#define OPENMP_TARGET_PARALLEL_FOR_SIMD_CLAUSE(Name) \
case OMPC_##Name: \
return true;
#include "clang/Basic/OpenMPKinds.def"
default:
break;
}
break;
case OMPD_target_simd:
switch (CKind) {
#define OPENMP_TARGET_SIMD_CLAUSE(Name) \
case OMPC_##Name: \
return true;
#include "clang/Basic/OpenMPKinds.def"
default:
break;
}
break;
case OMPD_teams_distribute:
switch (CKind) {
#define OPENMP_TEAMS_DISTRIBUTE_CLAUSE(Name) \
case OMPC_##Name: \
return true;
#include "clang/Basic/OpenMPKinds.def"
default:
break;
}
break;
case OMPD_teams_distribute_simd:
if (OpenMPVersion < 50 && CKind == OMPC_if)
return false;
switch (CKind) {
#define OPENMP_TEAMS_DISTRIBUTE_SIMD_CLAUSE(Name) \
case OMPC_##Name: \
return true;
#include "clang/Basic/OpenMPKinds.def"
default:
break;
}
break;
case OMPD_teams_distribute_parallel_for_simd:
switch (CKind) {
#define OPENMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(Name) \
case OMPC_##Name: \
return true;
#include "clang/Basic/OpenMPKinds.def"
default:
break;
}
break;
case OMPD_teams_distribute_parallel_for:
switch (CKind) {
#define OPENMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_CLAUSE(Name) \
case OMPC_##Name: \
return true;
#include "clang/Basic/OpenMPKinds.def"
default:
break;
}
break;
case OMPD_target_teams:
switch (CKind) {
#define OPENMP_TARGET_TEAMS_CLAUSE(Name) \
case OMPC_##Name: \
return true;
#include "clang/Basic/OpenMPKinds.def"
default:
break;
}
break;
case OMPD_target_teams_distribute:
switch (CKind) {
#define OPENMP_TARGET_TEAMS_DISTRIBUTE_CLAUSE(Name) \
case OMPC_##Name: \
return true;
#include "clang/Basic/OpenMPKinds.def"
default:
break;
}
break;
case OMPD_target_teams_distribute_parallel_for:
switch (CKind) {
#define OPENMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_CLAUSE(Name) \
case OMPC_##Name: \
return true;
#include "clang/Basic/OpenMPKinds.def"
default:
break;
}
break;
case OMPD_target_teams_distribute_parallel_for_simd:
switch (CKind) {
#define OPENMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(Name) \
case OMPC_##Name: \
return true;
#include "clang/Basic/OpenMPKinds.def"
default:
break;
}
break;
case OMPD_target_teams_distribute_simd:
switch (CKind) {
#define OPENMP_TARGET_TEAMS_DISTRIBUTE_SIMD_CLAUSE(Name) \
case OMPC_##Name: \
return true;
#include "clang/Basic/OpenMPKinds.def"
default:
break;
}
break;
case OMPD_taskgroup:
switch (CKind) {
#define OPENMP_TASKGROUP_CLAUSE(Name) \
case OMPC_##Name: \
return true;
#include "clang/Basic/OpenMPKinds.def"
default:
break;
}
break;
case OMPD_declare_mapper:
switch (CKind) {
#define OPENMP_DECLARE_MAPPER_CLAUSE(Name) \
case OMPC_##Name: \
return true;
#include "clang/Basic/OpenMPKinds.def"
default:
break;
}
break;
case OMPD_allocate:
switch (CKind) {
#define OPENMP_ALLOCATE_CLAUSE(Name) \
case OMPC_##Name: \
return true;
#include "clang/Basic/OpenMPKinds.def"
default:
break;
}
break;
case OMPD_declare_variant:
switch (CKind) {
#define OPENMP_DECLARE_VARIANT_CLAUSE(Name) \
case OMPC_##Name: \
return true;
#include "clang/Basic/OpenMPKinds.def"
default:
break;
}
break;
case OMPD_begin_declare_variant:
case OMPD_end_declare_variant:
case OMPD_declare_target:
case OMPD_end_declare_target:
case OMPD_unknown:
case OMPD_threadprivate:
case OMPD_section:
case OMPD_master:
case OMPD_taskyield:
case OMPD_barrier:
case OMPD_taskwait:
case OMPD_cancellation_point:
case OMPD_declare_reduction:
case OMPD_declare_simd:
break;
}
return false;
}
bool clang::isOpenMPLoopDirective(OpenMPDirectiveKind DKind) {
return DKind == OMPD_simd || DKind == OMPD_for || DKind == OMPD_for_simd ||
DKind == OMPD_parallel_for || DKind == OMPD_parallel_for_simd ||

1
clang/lib/Tooling/CMakeLists.txt
View File

@ -1,5 +1,6 @@
set(LLVM_LINK_COMPONENTS
Option
FrontendOpenMP
Support
)

5
clang/lib/Tooling/Transformer/CMakeLists.txt
View File

@ -1,4 +1,7 @@
set(LLVM_LINK_COMPONENTS Support)
set(LLVM_LINK_COMPONENTS
FrontendOpenMP
Support
)
add_clang_library(clangTransformer
RangeSelector.cpp

1
clang/unittests/AST/CMakeLists.txt
View File

@ -1,4 +1,5 @@
set(LLVM_LINK_COMPONENTS
FrontendOpenMP
Support
)

1
clang/unittests/ASTMatchers/CMakeLists.txt
View File

@ -1,4 +1,5 @@
set(LLVM_LINK_COMPONENTS
FrontendOpenMP
Support
)

1
clang/unittests/ASTMatchers/Dynamic/CMakeLists.txt
View File

@ -1,4 +1,5 @@
set(LLVM_LINK_COMPONENTS
FrontendOpenMP
Support
)

1
clang/unittests/Analysis/CMakeLists.txt
View File

@ -1,4 +1,5 @@
set(LLVM_LINK_COMPONENTS
FrontendOpenMP
Support
)

1
clang/unittests/Rename/CMakeLists.txt
View File

@ -1,4 +1,5 @@
set(LLVM_LINK_COMPONENTS
FrontendOpenMP
support
)

1
clang/unittests/Sema/CMakeLists.txt
View File

@ -1,4 +1,5 @@
set(LLVM_LINK_COMPONENTS
FrontendOpenMP
Support
)

1
clang/unittests/StaticAnalyzer/CMakeLists.txt
View File

@ -1,4 +1,5 @@
set(LLVM_LINK_COMPONENTS
FrontendOpenMP
Support
)

1
clang/unittests/Tooling/CMakeLists.txt
View File

@ -1,5 +1,6 @@
set(LLVM_LINK_COMPONENTS
${LLVM_TARGETS_TO_BUILD}
FrontendOpenMP
Support
)

3
llvm/include/llvm/Frontend/OpenMP/OMPConstants.h
View File

@ -100,6 +100,9 @@ Clause getOpenMPClauseKind(StringRef Str);
/// Return a textual representation of the clause \p C.
StringRef getOpenMPClauseName(Clause C);
/// Return true if \p C is a valid clause for \p D in version \p Version.
bool isAllowedClauseForDirective(Directive D, Clause C, unsigned Version);
/// Forward declarations for LLVM-IR types (simple, function and structure) are
/// generated below. Their names are defined and used in OpenMP/OMPKinds.def.
/// Here we provide the forward declarations, the initializeTypes function will

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

@ -710,3 +710,732 @@ OMP_LAST_TRAIT_PROPERTY(
#undef __OMP_REQUIRES_TRAIT
#undef OMP_REQUIRES_TRAIT
///}
/// Clauses allowed per directive
///
///{
#ifndef OMP_DIRECTIVE_CLAUSE
#define OMP_DIRECTIVE_CLAUSE(Directive, MinVersion, MaxVersion, Clause)
#endif
#define __OMP_DIRECTIVE_CLAUSE(Directive, MinVersion, MaxVersion, Clause) \
OMP_DIRECTIVE_CLAUSE(OMPD_##Directive, unsigned(MinVersion), \
unsigned(MaxVersion), OMPC_##Clause)
__OMP_DIRECTIVE_CLAUSE(scan, 50, ~0, inclusive)
__OMP_DIRECTIVE_CLAUSE(scan, 50, ~0, exclusive)
__OMP_DIRECTIVE_CLAUSE(parallel, 1, ~0, if)
__OMP_DIRECTIVE_CLAUSE(parallel, 1, ~0, num_threads)
__OMP_DIRECTIVE_CLAUSE(parallel, 1, ~0, default)
__OMP_DIRECTIVE_CLAUSE(parallel, 1, ~0, proc_bind)
__OMP_DIRECTIVE_CLAUSE(parallel, 1, ~0, private)
__OMP_DIRECTIVE_CLAUSE(parallel, 1, ~0, firstprivate)
__OMP_DIRECTIVE_CLAUSE(parallel, 1, ~0, shared)
__OMP_DIRECTIVE_CLAUSE(parallel, 1, ~0, reduction)
__OMP_DIRECTIVE_CLAUSE(parallel, 1, ~0, copyin)
__OMP_DIRECTIVE_CLAUSE(parallel, 1, ~0, allocate)
__OMP_DIRECTIVE_CLAUSE(simd, 1, ~0, private)
__OMP_DIRECTIVE_CLAUSE(simd, 1, ~0, lastprivate)
__OMP_DIRECTIVE_CLAUSE(simd, 1, ~0, linear)
__OMP_DIRECTIVE_CLAUSE(simd, 1, ~0, aligned)
__OMP_DIRECTIVE_CLAUSE(simd, 1, ~0, safelen)
__OMP_DIRECTIVE_CLAUSE(simd, 1, ~0, simdlen)
__OMP_DIRECTIVE_CLAUSE(simd, 1, ~0, collapse)
__OMP_DIRECTIVE_CLAUSE(simd, 1, ~0, reduction)
__OMP_DIRECTIVE_CLAUSE(simd, 1, ~0, allocate)
__OMP_DIRECTIVE_CLAUSE(simd, 50, ~0, if)
__OMP_DIRECTIVE_CLAUSE(simd, 50, ~0, nontemporal)
__OMP_DIRECTIVE_CLAUSE(simd, 50, ~0, order)
__OMP_DIRECTIVE_CLAUSE(for, 1, ~0, private)
__OMP_DIRECTIVE_CLAUSE(for, 1, ~0, lastprivate)
__OMP_DIRECTIVE_CLAUSE(for, 1, ~0, firstprivate)
__OMP_DIRECTIVE_CLAUSE(for, 1, ~0, reduction)
__OMP_DIRECTIVE_CLAUSE(for, 1, ~0, collapse)
__OMP_DIRECTIVE_CLAUSE(for, 1, ~0, schedule)
__OMP_DIRECTIVE_CLAUSE(for, 1, ~0, ordered)
__OMP_DIRECTIVE_CLAUSE(for, 1, ~0, nowait)
__OMP_DIRECTIVE_CLAUSE(for, 1, ~0, linear)
__OMP_DIRECTIVE_CLAUSE(for, 1, ~0, allocate)
__OMP_DIRECTIVE_CLAUSE(for, 50, ~0, order)
__OMP_DIRECTIVE_CLAUSE(for_simd, 1, ~0, private)
__OMP_DIRECTIVE_CLAUSE(for_simd, 1, ~0, firstprivate)
__OMP_DIRECTIVE_CLAUSE(for_simd, 1, ~0, lastprivate)
__OMP_DIRECTIVE_CLAUSE(for_simd, 1, ~0, reduction)
__OMP_DIRECTIVE_CLAUSE(for_simd, 1, ~0, schedule)
__OMP_DIRECTIVE_CLAUSE(for_simd, 1, ~0, collapse)
__OMP_DIRECTIVE_CLAUSE(for_simd, 1, ~0, nowait)
__OMP_DIRECTIVE_CLAUSE(for_simd, 1, ~0, safelen)
__OMP_DIRECTIVE_CLAUSE(for_simd, 1, ~0, simdlen)
__OMP_DIRECTIVE_CLAUSE(for_simd, 1, ~0, linear)
__OMP_DIRECTIVE_CLAUSE(for_simd, 1, ~0, aligned)
__OMP_DIRECTIVE_CLAUSE(for_simd, 1, ~1, ordered)
__OMP_DIRECTIVE_CLAUSE(for_simd, 1, ~0, allocate)
__OMP_DIRECTIVE_CLAUSE(for_simd, 50, ~0, if)
__OMP_DIRECTIVE_CLAUSE(for_simd, 50, ~0, nontemporal)
__OMP_DIRECTIVE_CLAUSE(for_simd, 50, ~0, order)
__OMP_DIRECTIVE_CLAUSE(sections, 1, ~0, private)
__OMP_DIRECTIVE_CLAUSE(sections, 1, ~0, lastprivate)
__OMP_DIRECTIVE_CLAUSE(sections, 1, ~0, firstprivate)
__OMP_DIRECTIVE_CLAUSE(sections, 1, ~0, reduction)
__OMP_DIRECTIVE_CLAUSE(sections, 1, ~0, nowait)
__OMP_DIRECTIVE_CLAUSE(sections, 1, ~0, allocate)
__OMP_DIRECTIVE_CLAUSE(single, 1, ~0, private)
__OMP_DIRECTIVE_CLAUSE(single, 1, ~0, firstprivate)
__OMP_DIRECTIVE_CLAUSE(single, 1, ~0, copyprivate)
__OMP_DIRECTIVE_CLAUSE(single, 1, ~0, nowait)
__OMP_DIRECTIVE_CLAUSE(single, 1, ~0, allocate)
__OMP_DIRECTIVE_CLAUSE(cancel, 1, ~0, if)
__OMP_DIRECTIVE_CLAUSE(parallel_for, 1, ~0, if)
__OMP_DIRECTIVE_CLAUSE(parallel_for, 1, ~0, num_threads)
__OMP_DIRECTIVE_CLAUSE(parallel_for, 1, ~0, default)
__OMP_DIRECTIVE_CLAUSE(parallel_for, 1, ~0, proc_bind)
__OMP_DIRECTIVE_CLAUSE(parallel_for, 1, ~0, private)
__OMP_DIRECTIVE_CLAUSE(parallel_for, 1, ~0, firstprivate)
__OMP_DIRECTIVE_CLAUSE(parallel_for, 1, ~0, shared)
__OMP_DIRECTIVE_CLAUSE(parallel_for, 1, ~0, reduction)
__OMP_DIRECTIVE_CLAUSE(parallel_for, 1, ~0, copyin)
__OMP_DIRECTIVE_CLAUSE(parallel_for, 1, ~0, lastprivate)
__OMP_DIRECTIVE_CLAUSE(parallel_for, 1, ~0, collapse)
__OMP_DIRECTIVE_CLAUSE(parallel_for, 1, ~0, schedule)
__OMP_DIRECTIVE_CLAUSE(parallel_for, 1, ~1, ordered)
__OMP_DIRECTIVE_CLAUSE(parallel_for, 1, ~0, linear)
__OMP_DIRECTIVE_CLAUSE(parallel_for, 1, ~0, allocate)
__OMP_DIRECTIVE_CLAUSE(parallel_for, 50, ~0, order)
__OMP_DIRECTIVE_CLAUSE(parallel_for_simd, 1, ~0, if)
__OMP_DIRECTIVE_CLAUSE(parallel_for_simd, 1, ~0, num_threads)
__OMP_DIRECTIVE_CLAUSE(parallel_for_simd, 1, ~0, default)
__OMP_DIRECTIVE_CLAUSE(parallel_for_simd, 1, ~0, proc_bind)
__OMP_DIRECTIVE_CLAUSE(parallel_for_simd, 1, ~0, private)
__OMP_DIRECTIVE_CLAUSE(parallel_for_simd, 1, ~0, firstprivate)
__OMP_DIRECTIVE_CLAUSE(parallel_for_simd, 1, ~0, shared)
__OMP_DIRECTIVE_CLAUSE(parallel_for_simd, 1, ~0, reduction)
__OMP_DIRECTIVE_CLAUSE(parallel_for_simd, 1, ~0, copyin)
__OMP_DIRECTIVE_CLAUSE(parallel_for_simd, 1, ~0, lastprivate)
__OMP_DIRECTIVE_CLAUSE(parallel_for_simd, 1, ~0, collapse)
__OMP_DIRECTIVE_CLAUSE(parallel_for_simd, 1, ~0, schedule)
__OMP_DIRECTIVE_CLAUSE(parallel_for_simd, 1, ~0, safelen)
__OMP_DIRECTIVE_CLAUSE(parallel_for_simd, 1, ~0, simdlen)
__OMP_DIRECTIVE_CLAUSE(parallel_for_simd, 1, ~0, linear)
__OMP_DIRECTIVE_CLAUSE(parallel_for_simd, 1, ~0, aligned)
__OMP_DIRECTIVE_CLAUSE(parallel_for_simd, 1, ~1, ordered)
__OMP_DIRECTIVE_CLAUSE(parallel_for_simd, 1, ~0, allocate)
__OMP_DIRECTIVE_CLAUSE(parallel_for_simd, 50, ~0, nontemporal)
__OMP_DIRECTIVE_CLAUSE(parallel_for_simd, 50, ~0, order)
__OMP_DIRECTIVE_CLAUSE(parallel_master, 1, ~0, if)
__OMP_DIRECTIVE_CLAUSE(parallel_master, 1, ~0, num_threads)
__OMP_DIRECTIVE_CLAUSE(parallel_master, 1, ~0, default)
__OMP_DIRECTIVE_CLAUSE(parallel_master, 1, ~0, private)
__OMP_DIRECTIVE_CLAUSE(parallel_master, 1, ~0, firstprivate)
__OMP_DIRECTIVE_CLAUSE(parallel_master, 1, ~0, shared)
__OMP_DIRECTIVE_CLAUSE(parallel_master, 1, ~0, copyin)
__OMP_DIRECTIVE_CLAUSE(parallel_master, 1, ~0, reduction)
__OMP_DIRECTIVE_CLAUSE(parallel_master, 1, ~0, proc_bind)
__OMP_DIRECTIVE_CLAUSE(parallel_master, 1, ~0, allocate)
__OMP_DIRECTIVE_CLAUSE(parallel_sections, 1, ~0, if)
__OMP_DIRECTIVE_CLAUSE(parallel_sections, 1, ~0, num_threads)
__OMP_DIRECTIVE_CLAUSE(parallel_sections, 1, ~0, default)
__OMP_DIRECTIVE_CLAUSE(parallel_sections, 1, ~0, proc_bind)
__OMP_DIRECTIVE_CLAUSE(parallel_sections, 1, ~0, private)
__OMP_DIRECTIVE_CLAUSE(parallel_sections, 1, ~0, firstprivate)
__OMP_DIRECTIVE_CLAUSE(parallel_sections, 1, ~0, shared)
__OMP_DIRECTIVE_CLAUSE(parallel_sections, 1, ~0, reduction)
__OMP_DIRECTIVE_CLAUSE(parallel_sections, 1, ~0, copyin)
__OMP_DIRECTIVE_CLAUSE(parallel_sections, 1, ~0, lastprivate)
__OMP_DIRECTIVE_CLAUSE(parallel_sections, 1, ~0, allocate)
__OMP_DIRECTIVE_CLAUSE(task, 1, ~0, if)
__OMP_DIRECTIVE_CLAUSE(task, 1, ~0, final)
__OMP_DIRECTIVE_CLAUSE(task, 1, ~0, default)
__OMP_DIRECTIVE_CLAUSE(task, 1, ~0, private)
__OMP_DIRECTIVE_CLAUSE(task, 1, ~0, firstprivate)
__OMP_DIRECTIVE_CLAUSE(task, 1, ~0, shared)
__OMP_DIRECTIVE_CLAUSE(task, 1, ~0, untied)
__OMP_DIRECTIVE_CLAUSE(task, 1, ~0, mergeable)
__OMP_DIRECTIVE_CLAUSE(task, 1, ~0, depend)
__OMP_DIRECTIVE_CLAUSE(task, 1, ~0, priority)
__OMP_DIRECTIVE_CLAUSE(task, 1, ~0, in_reduction)
__OMP_DIRECTIVE_CLAUSE(task, 1, ~0, allocate)
__OMP_DIRECTIVE_CLAUSE(task, 50, ~0, detach)
__OMP_DIRECTIVE_CLAUSE(atomic, 1, ~0, read)
__OMP_DIRECTIVE_CLAUSE(atomic, 1, ~0, write)
__OMP_DIRECTIVE_CLAUSE(atomic, 1, ~0, update)
__OMP_DIRECTIVE_CLAUSE(atomic, 1, ~0, capture)
__OMP_DIRECTIVE_CLAUSE(atomic, 1, ~0, seq_cst)
__OMP_DIRECTIVE_CLAUSE(atomic, 50, ~0, acq_rel)
__OMP_DIRECTIVE_CLAUSE(atomic, 50, ~0, acquire)
__OMP_DIRECTIVE_CLAUSE(atomic, 50, ~0, release)
__OMP_DIRECTIVE_CLAUSE(atomic, 50, ~0, relaxed)
__OMP_DIRECTIVE_CLAUSE(atomic, 50, ~0, hint)
__OMP_DIRECTIVE_CLAUSE(target, 1, ~0, if)
__OMP_DIRECTIVE_CLAUSE(target, 1, ~0, device)
__OMP_DIRECTIVE_CLAUSE(target, 1, ~0, map)
__OMP_DIRECTIVE_CLAUSE(target, 1, ~0, private)
__OMP_DIRECTIVE_CLAUSE(target, 1, ~0, nowait)
__OMP_DIRECTIVE_CLAUSE(target, 1, ~0, depend)
__OMP_DIRECTIVE_CLAUSE(target, 1, ~0, defaultmap)
__OMP_DIRECTIVE_CLAUSE(target, 1, ~0, firstprivate)
__OMP_DIRECTIVE_CLAUSE(target, 1, ~0, is_device_ptr)
__OMP_DIRECTIVE_CLAUSE(target, 1, ~0, reduction)
__OMP_DIRECTIVE_CLAUSE(target, 1, ~0, allocate)
__OMP_DIRECTIVE_CLAUSE(requires, 1, ~0, unified_address)
__OMP_DIRECTIVE_CLAUSE(requires, 1, ~0, unified_shared_memory)
__OMP_DIRECTIVE_CLAUSE(requires, 1, ~0, reverse_offload)
__OMP_DIRECTIVE_CLAUSE(requires, 1, ~0, dynamic_allocators)
__OMP_DIRECTIVE_CLAUSE(requires, 1, ~0, atomic_default_mem_order)
__OMP_DIRECTIVE_CLAUSE(allocate, 1, ~0, allocator)
__OMP_DIRECTIVE_CLAUSE(target_data, 1, ~0, if)
__OMP_DIRECTIVE_CLAUSE(target_data, 1, ~0, device)
__OMP_DIRECTIVE_CLAUSE(target_data, 1, ~0, map)
__OMP_DIRECTIVE_CLAUSE(target_data, 1, ~0, use_device_ptr)
__OMP_DIRECTIVE_CLAUSE(target_enter_data, 1, ~0, if)
__OMP_DIRECTIVE_CLAUSE(target_enter_data, 1, ~0, device)
__OMP_DIRECTIVE_CLAUSE(target_enter_data, 1, ~0, map)
__OMP_DIRECTIVE_CLAUSE(target_enter_data, 1, ~0, nowait)
__OMP_DIRECTIVE_CLAUSE(target_enter_data, 1, ~0, depend)
__OMP_DIRECTIVE_CLAUSE(target_exit_data, 1, ~0, if)
__OMP_DIRECTIVE_CLAUSE(target_exit_data, 1, ~0, device)
__OMP_DIRECTIVE_CLAUSE(target_exit_data, 1, ~0, map)
__OMP_DIRECTIVE_CLAUSE(target_exit_data, 1, ~0, nowait)
__OMP_DIRECTIVE_CLAUSE(target_exit_data, 1, ~0, depend)
__OMP_DIRECTIVE_CLAUSE(target_parallel, 1, ~0, if)
__OMP_DIRECTIVE_CLAUSE(target_parallel, 1, ~0, device)
__OMP_DIRECTIVE_CLAUSE(target_parallel, 1, ~0, map)
__OMP_DIRECTIVE_CLAUSE(target_parallel, 1, ~0, private)
__OMP_DIRECTIVE_CLAUSE(target_parallel, 1, ~0, firstprivate)
__OMP_DIRECTIVE_CLAUSE(target_parallel, 1, ~0, nowait)
__OMP_DIRECTIVE_CLAUSE(target_parallel, 1, ~0, depend)
__OMP_DIRECTIVE_CLAUSE(target_parallel, 1, ~0, defaultmap)
__OMP_DIRECTIVE_CLAUSE(target_parallel, 1, ~0, num_threads)
__OMP_DIRECTIVE_CLAUSE(target_parallel, 1, ~0, default)
__OMP_DIRECTIVE_CLAUSE(target_parallel, 1, ~0, proc_bind)
__OMP_DIRECTIVE_CLAUSE(target_parallel, 1, ~0, shared)
__OMP_DIRECTIVE_CLAUSE(target_parallel, 1, ~0, reduction)
__OMP_DIRECTIVE_CLAUSE(target_parallel, 1, ~0, is_device_ptr)
__OMP_DIRECTIVE_CLAUSE(target_parallel, 1, ~0, allocate)
__OMP_DIRECTIVE_CLAUSE(target_parallel_for, 1, ~0, if)
__OMP_DIRECTIVE_CLAUSE(target_parallel_for, 1, ~0, device)
__OMP_DIRECTIVE_CLAUSE(target_parallel_for, 1, ~0, map)
__OMP_DIRECTIVE_CLAUSE(target_parallel_for, 1, ~0, private)
__OMP_DIRECTIVE_CLAUSE(target_parallel_for, 1, ~0, firstprivate)
__OMP_DIRECTIVE_CLAUSE(target_parallel_for, 1, ~0, lastprivate)
__OMP_DIRECTIVE_CLAUSE(target_parallel_for, 1, ~0, nowait)
__OMP_DIRECTIVE_CLAUSE(target_parallel_for, 1, ~0, depend)
__OMP_DIRECTIVE_CLAUSE(target_parallel_for, 1, ~0, defaultmap)
__OMP_DIRECTIVE_CLAUSE(target_parallel_for, 1, ~0, num_threads)
__OMP_DIRECTIVE_CLAUSE(target_parallel_for, 1, ~0, default)
__OMP_DIRECTIVE_CLAUSE(target_parallel_for, 1, ~0, proc_bind)
__OMP_DIRECTIVE_CLAUSE(target_parallel_for, 1, ~0, shared)
__OMP_DIRECTIVE_CLAUSE(target_parallel_for, 1, ~0, reduction)
__OMP_DIRECTIVE_CLAUSE(target_parallel_for, 1, ~0, collapse)
__OMP_DIRECTIVE_CLAUSE(target_parallel_for, 1, ~0, schedule)
__OMP_DIRECTIVE_CLAUSE(target_parallel_for, 1, ~1, ordered)
__OMP_DIRECTIVE_CLAUSE(target_parallel_for, 1, ~0, linear)
__OMP_DIRECTIVE_CLAUSE(target_parallel_for, 1, ~0, is_device_ptr)
__OMP_DIRECTIVE_CLAUSE(target_parallel_for, 1, ~0, allocate)
__OMP_DIRECTIVE_CLAUSE(target_parallel_for, 50, ~0, order)
__OMP_DIRECTIVE_CLAUSE(target_update, 1, ~0, if)
__OMP_DIRECTIVE_CLAUSE(target_update, 1, ~0, device)
__OMP_DIRECTIVE_CLAUSE(target_update, 1, ~0, to)
__OMP_DIRECTIVE_CLAUSE(target_update, 1, ~0, from)
__OMP_DIRECTIVE_CLAUSE(target_update, 1, ~0, nowait)
__OMP_DIRECTIVE_CLAUSE(target_update, 1, ~0, depend)
__OMP_DIRECTIVE_CLAUSE(teams, 1, ~0, default)
__OMP_DIRECTIVE_CLAUSE(teams, 1, ~0, private)
__OMP_DIRECTIVE_CLAUSE(teams, 1, ~0, firstprivate)
__OMP_DIRECTIVE_CLAUSE(teams, 1, ~0, shared)
__OMP_DIRECTIVE_CLAUSE(teams, 1, ~0, reduction)
__OMP_DIRECTIVE_CLAUSE(teams, 1, ~0, num_teams)
__OMP_DIRECTIVE_CLAUSE(teams, 1, ~0, thread_limit)
__OMP_DIRECTIVE_CLAUSE(teams, 1, ~0, allocate)
__OMP_DIRECTIVE_CLAUSE(ordered, 1, ~0, threads)
__OMP_DIRECTIVE_CLAUSE(ordered, 1, ~0, simd)
__OMP_DIRECTIVE_CLAUSE(ordered, 1, ~0, depend)
__OMP_DIRECTIVE_CLAUSE(taskloop, 1, ~0, if)
__OMP_DIRECTIVE_CLAUSE(taskloop, 1, ~0, shared)
__OMP_DIRECTIVE_CLAUSE(taskloop, 1, ~0, private)
__OMP_DIRECTIVE_CLAUSE(taskloop, 1, ~0, firstprivate)
__OMP_DIRECTIVE_CLAUSE(taskloop, 1, ~0, lastprivate)
__OMP_DIRECTIVE_CLAUSE(taskloop, 1, ~0, default)
__OMP_DIRECTIVE_CLAUSE(taskloop, 1, ~0, collapse)
__OMP_DIRECTIVE_CLAUSE(taskloop, 1, ~0, final)
__OMP_DIRECTIVE_CLAUSE(taskloop, 1, ~0, untied)
__OMP_DIRECTIVE_CLAUSE(taskloop, 1, ~0, mergeable)
__OMP_DIRECTIVE_CLAUSE(taskloop, 1, ~0, priority)
__OMP_DIRECTIVE_CLAUSE(taskloop, 1, ~0, grainsize)
__OMP_DIRECTIVE_CLAUSE(taskloop, 1, ~0, nogroup)
__OMP_DIRECTIVE_CLAUSE(taskloop, 1, ~0, num_tasks)
__OMP_DIRECTIVE_CLAUSE(taskloop, 1, ~0, reduction)
__OMP_DIRECTIVE_CLAUSE(taskloop, 1, ~0, in_reduction)
__OMP_DIRECTIVE_CLAUSE(taskloop, 1, ~0, allocate)
__OMP_DIRECTIVE_CLAUSE(taskloop_simd, 1, ~0, if)
__OMP_DIRECTIVE_CLAUSE(taskloop_simd, 1, ~0, shared)
__OMP_DIRECTIVE_CLAUSE(taskloop_simd, 1, ~0, private)
__OMP_DIRECTIVE_CLAUSE(taskloop_simd, 1, ~0, firstprivate)
__OMP_DIRECTIVE_CLAUSE(taskloop_simd, 1, ~0, lastprivate)
__OMP_DIRECTIVE_CLAUSE(taskloop_simd, 1, ~0, default)
__OMP_DIRECTIVE_CLAUSE(taskloop_simd, 1, ~0, collapse)
__OMP_DIRECTIVE_CLAUSE(taskloop_simd, 1, ~0, final)
__OMP_DIRECTIVE_CLAUSE(taskloop_simd, 1, ~0, untied)
__OMP_DIRECTIVE_CLAUSE(taskloop_simd, 1, ~0, mergeable)
__OMP_DIRECTIVE_CLAUSE(taskloop_simd, 1, ~0, priority)
__OMP_DIRECTIVE_CLAUSE(taskloop_simd, 1, ~0, linear)
__OMP_DIRECTIVE_CLAUSE(taskloop_simd, 1, ~0, aligned)
__OMP_DIRECTIVE_CLAUSE(taskloop_simd, 1, ~0, safelen)
__OMP_DIRECTIVE_CLAUSE(taskloop_simd, 1, ~0, simdlen)
__OMP_DIRECTIVE_CLAUSE(taskloop_simd, 1, ~0, grainsize)
__OMP_DIRECTIVE_CLAUSE(taskloop_simd, 1, ~0, nogroup)
__OMP_DIRECTIVE_CLAUSE(taskloop_simd, 1, ~0, num_tasks)
__OMP_DIRECTIVE_CLAUSE(taskloop_simd, 1, ~0, reduction)
__OMP_DIRECTIVE_CLAUSE(taskloop_simd, 1, ~0, in_reduction)
__OMP_DIRECTIVE_CLAUSE(taskloop_simd, 1, ~0, allocate)
__OMP_DIRECTIVE_CLAUSE(taskloop_simd, 50, ~0, nontemporal)
__OMP_DIRECTIVE_CLAUSE(taskloop_simd, 50, ~0, order)
__OMP_DIRECTIVE_CLAUSE(master_taskloop, 1, ~0, if)
__OMP_DIRECTIVE_CLAUSE(master_taskloop, 1, ~0, shared)
__OMP_DIRECTIVE_CLAUSE(master_taskloop, 1, ~0, private)
__OMP_DIRECTIVE_CLAUSE(master_taskloop, 1, ~0, firstprivate)
__OMP_DIRECTIVE_CLAUSE(master_taskloop, 1, ~0, lastprivate)
__OMP_DIRECTIVE_CLAUSE(master_taskloop, 1, ~0, default)
__OMP_DIRECTIVE_CLAUSE(master_taskloop, 1, ~0, collapse)
__OMP_DIRECTIVE_CLAUSE(master_taskloop, 1, ~0, final)
__OMP_DIRECTIVE_CLAUSE(master_taskloop, 1, ~0, untied)
__OMP_DIRECTIVE_CLAUSE(master_taskloop, 1, ~0, mergeable)
__OMP_DIRECTIVE_CLAUSE(master_taskloop, 1, ~0, priority)
__OMP_DIRECTIVE_CLAUSE(master_taskloop, 1, ~0, grainsize)
__OMP_DIRECTIVE_CLAUSE(master_taskloop, 1, ~0, nogroup)
__OMP_DIRECTIVE_CLAUSE(master_taskloop, 1, ~0, num_tasks)
__OMP_DIRECTIVE_CLAUSE(master_taskloop, 1, ~0, reduction)
__OMP_DIRECTIVE_CLAUSE(master_taskloop, 1, ~0, in_reduction)
__OMP_DIRECTIVE_CLAUSE(master_taskloop, 1, ~0, allocate)
__OMP_DIRECTIVE_CLAUSE(master_taskloop_simd, 1, ~0, if)
__OMP_DIRECTIVE_CLAUSE(master_taskloop_simd, 1, ~0, shared)
__OMP_DIRECTIVE_CLAUSE(master_taskloop_simd, 1, ~0, private)
__OMP_DIRECTIVE_CLAUSE(master_taskloop_simd, 1, ~0, firstprivate)
__OMP_DIRECTIVE_CLAUSE(master_taskloop_simd, 1, ~0, lastprivate)
__OMP_DIRECTIVE_CLAUSE(master_taskloop_simd, 1, ~0, default)
__OMP_DIRECTIVE_CLAUSE(master_taskloop_simd, 1, ~0, collapse)
__OMP_DIRECTIVE_CLAUSE(master_taskloop_simd, 1, ~0, final)
__OMP_DIRECTIVE_CLAUSE(master_taskloop_simd, 1, ~0, untied)
__OMP_DIRECTIVE_CLAUSE(master_taskloop_simd, 1, ~0, mergeable)
__OMP_DIRECTIVE_CLAUSE(master_taskloop_simd, 1, ~0, priority)
__OMP_DIRECTIVE_CLAUSE(master_taskloop_simd, 1, ~0, linear)
__OMP_DIRECTIVE_CLAUSE(master_taskloop_simd, 1, ~0, aligned)
__OMP_DIRECTIVE_CLAUSE(master_taskloop_simd, 1, ~0, safelen)
__OMP_DIRECTIVE_CLAUSE(master_taskloop_simd, 1, ~0, simdlen)
__OMP_DIRECTIVE_CLAUSE(master_taskloop_simd, 1, ~0, grainsize)
__OMP_DIRECTIVE_CLAUSE(master_taskloop_simd, 1, ~0, nogroup)
__OMP_DIRECTIVE_CLAUSE(master_taskloop_simd, 1, ~0, num_tasks)
__OMP_DIRECTIVE_CLAUSE(master_taskloop_simd, 1, ~0, reduction)
__OMP_DIRECTIVE_CLAUSE(master_taskloop_simd, 1, ~0, in_reduction)
__OMP_DIRECTIVE_CLAUSE(master_taskloop_simd, 1, ~0, allocate)
__OMP_DIRECTIVE_CLAUSE(master_taskloop_simd, 50, ~0, nontemporal)
__OMP_DIRECTIVE_CLAUSE(master_taskloop_simd, 50, ~0, order)
__OMP_DIRECTIVE_CLAUSE(parallel_master_taskloop, 1, ~0, if)
__OMP_DIRECTIVE_CLAUSE(parallel_master_taskloop, 1, ~0, shared)
__OMP_DIRECTIVE_CLAUSE(parallel_master_taskloop, 1, ~0, private)
__OMP_DIRECTIVE_CLAUSE(parallel_master_taskloop, 1, ~0, firstprivate)
__OMP_DIRECTIVE_CLAUSE(parallel_master_taskloop, 1, ~0, lastprivate)
__OMP_DIRECTIVE_CLAUSE(parallel_master_taskloop, 1, ~0, default)
__OMP_DIRECTIVE_CLAUSE(parallel_master_taskloop, 1, ~0, collapse)
__OMP_DIRECTIVE_CLAUSE(parallel_master_taskloop, 1, ~0, final)
__OMP_DIRECTIVE_CLAUSE(parallel_master_taskloop, 1, ~0, untied)
__OMP_DIRECTIVE_CLAUSE(parallel_master_taskloop, 1, ~0, mergeable)
__OMP_DIRECTIVE_CLAUSE(parallel_master_taskloop, 1, ~0, priority)
__OMP_DIRECTIVE_CLAUSE(parallel_master_taskloop, 1, ~0, grainsize)
__OMP_DIRECTIVE_CLAUSE(parallel_master_taskloop, 1, ~0, nogroup)
__OMP_DIRECTIVE_CLAUSE(parallel_master_taskloop, 1, ~0, num_tasks)
__OMP_DIRECTIVE_CLAUSE(parallel_master_taskloop, 1, ~0, reduction)
__OMP_DIRECTIVE_CLAUSE(parallel_master_taskloop, 1, ~0, allocate)
__OMP_DIRECTIVE_CLAUSE(parallel_master_taskloop, 1, ~0, num_threads)
__OMP_DIRECTIVE_CLAUSE(parallel_master_taskloop, 1, ~0, proc_bind)
__OMP_DIRECTIVE_CLAUSE(parallel_master_taskloop, 1, ~0, copyin)
__OMP_DIRECTIVE_CLAUSE(parallel_master_taskloop_simd, 1, ~0, if)
__OMP_DIRECTIVE_CLAUSE(parallel_master_taskloop_simd, 1, ~0, shared)
__OMP_DIRECTIVE_CLAUSE(parallel_master_taskloop_simd, 1, ~0, private)
__OMP_DIRECTIVE_CLAUSE(parallel_master_taskloop_simd, 1, ~0, firstprivate)
__OMP_DIRECTIVE_CLAUSE(parallel_master_taskloop_simd, 1, ~0, lastprivate)
__OMP_DIRECTIVE_CLAUSE(parallel_master_taskloop_simd, 1, ~0, default)
__OMP_DIRECTIVE_CLAUSE(parallel_master_taskloop_simd, 1, ~0, collapse)
__OMP_DIRECTIVE_CLAUSE(parallel_master_taskloop_simd, 1, ~0, final)
__OMP_DIRECTIVE_CLAUSE(parallel_master_taskloop_simd, 1, ~0, untied)
__OMP_DIRECTIVE_CLAUSE(parallel_master_taskloop_simd, 1, ~0, mergeable)
__OMP_DIRECTIVE_CLAUSE(parallel_master_taskloop_simd, 1, ~0, priority)
__OMP_DIRECTIVE_CLAUSE(parallel_master_taskloop_simd, 1, ~0, grainsize)
__OMP_DIRECTIVE_CLAUSE(parallel_master_taskloop_simd, 1, ~0, nogroup)
__OMP_DIRECTIVE_CLAUSE(parallel_master_taskloop_simd, 1, ~0, num_tasks)
__OMP_DIRECTIVE_CLAUSE(parallel_master_taskloop_simd, 1, ~0, reduction)
__OMP_DIRECTIVE_CLAUSE(parallel_master_taskloop_simd, 1, ~0, allocate)
__OMP_DIRECTIVE_CLAUSE(parallel_master_taskloop_simd, 1, ~0, num_threads)
__OMP_DIRECTIVE_CLAUSE(parallel_master_taskloop_simd, 1, ~0, proc_bind)
__OMP_DIRECTIVE_CLAUSE(parallel_master_taskloop_simd, 1, ~0, copyin)
__OMP_DIRECTIVE_CLAUSE(parallel_master_taskloop_simd, 1, ~0, linear)
__OMP_DIRECTIVE_CLAUSE(parallel_master_taskloop_simd, 1, ~0, aligned)
__OMP_DIRECTIVE_CLAUSE(parallel_master_taskloop_simd, 1, ~0, safelen)
__OMP_DIRECTIVE_CLAUSE(parallel_master_taskloop_simd, 1, ~0, simdlen)
__OMP_DIRECTIVE_CLAUSE(parallel_master_taskloop_simd, 50, ~0, nontemporal)
__OMP_DIRECTIVE_CLAUSE(parallel_master_taskloop_simd, 50, ~0, order)
__OMP_DIRECTIVE_CLAUSE(critical, 1, ~0, hint)
__OMP_DIRECTIVE_CLAUSE(distribute, 1, ~0, private)
__OMP_DIRECTIVE_CLAUSE(distribute, 1, ~0, firstprivate)
__OMP_DIRECTIVE_CLAUSE(distribute, 1, ~0, lastprivate)
__OMP_DIRECTIVE_CLAUSE(distribute, 1, ~0, collapse)
__OMP_DIRECTIVE_CLAUSE(distribute, 1, ~0, dist_schedule)
__OMP_DIRECTIVE_CLAUSE(distribute, 1, ~0, allocate)
__OMP_DIRECTIVE_CLAUSE(distribute_parallel_for, 1, ~0, firstprivate)
__OMP_DIRECTIVE_CLAUSE(distribute_parallel_for, 1, ~0, lastprivate)
__OMP_DIRECTIVE_CLAUSE(distribute_parallel_for, 1, ~0, collapse)
__OMP_DIRECTIVE_CLAUSE(distribute_parallel_for, 1, ~0, dist_schedule)
__OMP_DIRECTIVE_CLAUSE(distribute_parallel_for, 1, ~0, if)
__OMP_DIRECTIVE_CLAUSE(distribute_parallel_for, 1, ~0, num_threads)
__OMP_DIRECTIVE_CLAUSE(distribute_parallel_for, 1, ~0, default)
__OMP_DIRECTIVE_CLAUSE(distribute_parallel_for, 1, ~0, proc_bind)
__OMP_DIRECTIVE_CLAUSE(distribute_parallel_for, 1, ~0, private)
__OMP_DIRECTIVE_CLAUSE(distribute_parallel_for, 1, ~0, shared)
__OMP_DIRECTIVE_CLAUSE(distribute_parallel_for, 1, ~0, reduction)
__OMP_DIRECTIVE_CLAUSE(distribute_parallel_for, 1, ~0, copyin)
__OMP_DIRECTIVE_CLAUSE(distribute_parallel_for, 1, ~0, schedule)
__OMP_DIRECTIVE_CLAUSE(distribute_parallel_for, 1, ~0, allocate)
__OMP_DIRECTIVE_CLAUSE(distribute_parallel_for, 50, ~0, order)
__OMP_DIRECTIVE_CLAUSE(distribute_parallel_for_simd, 1, ~0, firstprivate)
__OMP_DIRECTIVE_CLAUSE(distribute_parallel_for_simd, 1, ~0, lastprivate)
__OMP_DIRECTIVE_CLAUSE(distribute_parallel_for_simd, 1, ~0, collapse)
__OMP_DIRECTIVE_CLAUSE(distribute_parallel_for_simd, 1, ~0, dist_schedule)
__OMP_DIRECTIVE_CLAUSE(distribute_parallel_for_simd, 1, ~0, if)
__OMP_DIRECTIVE_CLAUSE(distribute_parallel_for_simd, 1, ~0, num_threads)
__OMP_DIRECTIVE_CLAUSE(distribute_parallel_for_simd, 1, ~0, default)
__OMP_DIRECTIVE_CLAUSE(distribute_parallel_for_simd, 1, ~0, proc_bind)
__OMP_DIRECTIVE_CLAUSE(distribute_parallel_for_simd, 1, ~0, private)
__OMP_DIRECTIVE_CLAUSE(distribute_parallel_for_simd, 1, ~0, shared)
__OMP_DIRECTIVE_CLAUSE(distribute_parallel_for_simd, 1, ~0, reduction)
__OMP_DIRECTIVE_CLAUSE(distribute_parallel_for_simd, 1, ~0, copyin)
__OMP_DIRECTIVE_CLAUSE(distribute_parallel_for_simd, 1, ~0, schedule)
__OMP_DIRECTIVE_CLAUSE(distribute_parallel_for_simd, 1, ~0, linear)
__OMP_DIRECTIVE_CLAUSE(distribute_parallel_for_simd, 1, ~0, aligned)
__OMP_DIRECTIVE_CLAUSE(distribute_parallel_for_simd, 1, ~0, safelen)
__OMP_DIRECTIVE_CLAUSE(distribute_parallel_for_simd, 1, ~0, simdlen)
__OMP_DIRECTIVE_CLAUSE(distribute_parallel_for_simd, 1, ~0, allocate)
__OMP_DIRECTIVE_CLAUSE(distribute_parallel_for_simd, 50, ~0, nontemporal)
__OMP_DIRECTIVE_CLAUSE(distribute_parallel_for_simd, 50, ~0, order)
__OMP_DIRECTIVE_CLAUSE(distribute_simd, 1, ~0, private)
__OMP_DIRECTIVE_CLAUSE(distribute_simd, 1, ~0, firstprivate)
__OMP_DIRECTIVE_CLAUSE(distribute_simd, 1, ~0, lastprivate)
__OMP_DIRECTIVE_CLAUSE(distribute_simd, 1, ~0, collapse)
__OMP_DIRECTIVE_CLAUSE(distribute_simd, 1, ~0, dist_schedule)
__OMP_DIRECTIVE_CLAUSE(distribute_simd, 1, ~0, linear)
__OMP_DIRECTIVE_CLAUSE(distribute_simd, 1, ~0, aligned)
__OMP_DIRECTIVE_CLAUSE(distribute_simd, 1, ~0, safelen)
__OMP_DIRECTIVE_CLAUSE(distribute_simd, 1, ~0, simdlen)
__OMP_DIRECTIVE_CLAUSE(distribute_simd, 1, ~0, reduction)
__OMP_DIRECTIVE_CLAUSE(distribute_simd, 1, ~0, allocate)
__OMP_DIRECTIVE_CLAUSE(distribute_simd, 50, ~0, if)
__OMP_DIRECTIVE_CLAUSE(distribute_simd, 50, ~0, nontemporal)
__OMP_DIRECTIVE_CLAUSE(distribute_simd, 50, ~0, order)
__OMP_DIRECTIVE_CLAUSE(target_parallel_for_simd, 1, ~0, if)
__OMP_DIRECTIVE_CLAUSE(target_parallel_for_simd, 1, ~0, device)
__OMP_DIRECTIVE_CLAUSE(target_parallel_for_simd, 1, ~0, map)
__OMP_DIRECTIVE_CLAUSE(target_parallel_for_simd, 1, ~0, private)
__OMP_DIRECTIVE_CLAUSE(target_parallel_for_simd, 1, ~0, firstprivate)
__OMP_DIRECTIVE_CLAUSE(target_parallel_for_simd, 1, ~0, lastprivate)
__OMP_DIRECTIVE_CLAUSE(target_parallel_for_simd, 1, ~0, nowait)
__OMP_DIRECTIVE_CLAUSE(target_parallel_for_simd, 1, ~0, depend)
__OMP_DIRECTIVE_CLAUSE(target_parallel_for_simd, 1, ~0, defaultmap)
__OMP_DIRECTIVE_CLAUSE(target_parallel_for_simd, 1, ~0, num_threads)
__OMP_DIRECTIVE_CLAUSE(target_parallel_for_simd, 1, ~0, default)
__OMP_DIRECTIVE_CLAUSE(target_parallel_for_simd, 1, ~0, proc_bind)
__OMP_DIRECTIVE_CLAUSE(target_parallel_for_simd, 1, ~0, shared)
__OMP_DIRECTIVE_CLAUSE(target_parallel_for_simd, 1, ~0, reduction)
__OMP_DIRECTIVE_CLAUSE(target_parallel_for_simd, 1, ~0, collapse)
__OMP_DIRECTIVE_CLAUSE(target_parallel_for_simd, 1, ~0, schedule)
__OMP_DIRECTIVE_CLAUSE(target_parallel_for_simd, 1, ~1, ordered)
__OMP_DIRECTIVE_CLAUSE(target_parallel_for_simd, 1, ~0, linear)
__OMP_DIRECTIVE_CLAUSE(target_parallel_for_simd, 1, ~0, safelen)
__OMP_DIRECTIVE_CLAUSE(target_parallel_for_simd, 1, ~0, simdlen)
__OMP_DIRECTIVE_CLAUSE(target_parallel_for_simd, 1, ~0, aligned)
__OMP_DIRECTIVE_CLAUSE(target_parallel_for_simd, 1, ~0, is_device_ptr)
__OMP_DIRECTIVE_CLAUSE(target_parallel_for_simd, 1, ~0, allocate)
__OMP_DIRECTIVE_CLAUSE(target_parallel_for_simd, 50, ~0, nontemporal)
__OMP_DIRECTIVE_CLAUSE(target_parallel_for_simd, 50, ~0, order)
__OMP_DIRECTIVE_CLAUSE(target_simd, 1, ~0, if)
__OMP_DIRECTIVE_CLAUSE(target_simd, 1, ~0, device)
__OMP_DIRECTIVE_CLAUSE(target_simd, 1, ~0, map)
__OMP_DIRECTIVE_CLAUSE(target_simd, 1, ~0, private)
__OMP_DIRECTIVE_CLAUSE(target_simd, 1, ~0, nowait)
__OMP_DIRECTIVE_CLAUSE(target_simd, 1, ~0, depend)
__OMP_DIRECTIVE_CLAUSE(target_simd, 1, ~0, defaultmap)
__OMP_DIRECTIVE_CLAUSE(target_simd, 1, ~0, firstprivate)
__OMP_DIRECTIVE_CLAUSE(target_simd, 1, ~0, is_device_ptr)
__OMP_DIRECTIVE_CLAUSE(target_simd, 1, ~0, lastprivate)
__OMP_DIRECTIVE_CLAUSE(target_simd, 1, ~0, linear)
__OMP_DIRECTIVE_CLAUSE(target_simd, 1, ~0, aligned)
__OMP_DIRECTIVE_CLAUSE(target_simd, 1, ~0, safelen)
__OMP_DIRECTIVE_CLAUSE(target_simd, 1, ~0, simdlen)
__OMP_DIRECTIVE_CLAUSE(target_simd, 1, ~0, collapse)
__OMP_DIRECTIVE_CLAUSE(target_simd, 1, ~0, reduction)
__OMP_DIRECTIVE_CLAUSE(target_simd, 1, ~0, allocate)
__OMP_DIRECTIVE_CLAUSE(target_simd, 50, ~0, nontemporal)
__OMP_DIRECTIVE_CLAUSE(target_simd, 50, ~0, order)
__OMP_DIRECTIVE_CLAUSE(teams_distribute, 1, ~0, default)
__OMP_DIRECTIVE_CLAUSE(teams_distribute, 1, ~0, private)
__OMP_DIRECTIVE_CLAUSE(teams_distribute, 1, ~0, firstprivate)
__OMP_DIRECTIVE_CLAUSE(teams_distribute, 1, ~0, shared)
__OMP_DIRECTIVE_CLAUSE(teams_distribute, 1, ~0, reduction)
__OMP_DIRECTIVE_CLAUSE(teams_distribute, 1, ~0, num_teams)
__OMP_DIRECTIVE_CLAUSE(teams_distribute, 1, ~0, thread_limit)
__OMP_DIRECTIVE_CLAUSE(teams_distribute, 1, ~0, lastprivate)
__OMP_DIRECTIVE_CLAUSE(teams_distribute, 1, ~0, collapse)
__OMP_DIRECTIVE_CLAUSE(teams_distribute, 1, ~0, dist_schedule)
__OMP_DIRECTIVE_CLAUSE(teams_distribute, 1, ~0, allocate)
__OMP_DIRECTIVE_CLAUSE(teams_distribute_simd, 1, ~0, default)
__OMP_DIRECTIVE_CLAUSE(teams_distribute_simd, 1, ~0, private)
__OMP_DIRECTIVE_CLAUSE(teams_distribute_simd, 1, ~0, firstprivate)
__OMP_DIRECTIVE_CLAUSE(teams_distribute_simd, 1, ~0, shared)
__OMP_DIRECTIVE_CLAUSE(teams_distribute_simd, 1, ~0, reduction)
__OMP_DIRECTIVE_CLAUSE(teams_distribute_simd, 1, ~0, num_teams)
__OMP_DIRECTIVE_CLAUSE(teams_distribute_simd, 1, ~0, thread_limit)
__OMP_DIRECTIVE_CLAUSE(teams_distribute_simd, 1, ~0, lastprivate)
__OMP_DIRECTIVE_CLAUSE(teams_distribute_simd, 1, ~0, collapse)
__OMP_DIRECTIVE_CLAUSE(teams_distribute_simd, 1, ~0, dist_schedule)
__OMP_DIRECTIVE_CLAUSE(teams_distribute_simd, 1, ~0, linear)
__OMP_DIRECTIVE_CLAUSE(teams_distribute_simd, 1, ~0, aligned)
__OMP_DIRECTIVE_CLAUSE(teams_distribute_simd, 1, ~0, safelen)
__OMP_DIRECTIVE_CLAUSE(teams_distribute_simd, 1, ~0, simdlen)
__OMP_DIRECTIVE_CLAUSE(teams_distribute_simd, 1, ~0, allocate)
__OMP_DIRECTIVE_CLAUSE(teams_distribute_simd, 50, ~0, if)
__OMP_DIRECTIVE_CLAUSE(teams_distribute_simd, 50, ~0, nontemporal)
__OMP_DIRECTIVE_CLAUSE(teams_distribute_simd, 50, ~0, order)
__OMP_DIRECTIVE_CLAUSE(teams_distribute_parallel_for_simd, 1, ~0, firstprivate)
__OMP_DIRECTIVE_CLAUSE(teams_distribute_parallel_for_simd, 1, ~0, lastprivate)
__OMP_DIRECTIVE_CLAUSE(teams_distribute_parallel_for_simd, 1, ~0, collapse)
__OMP_DIRECTIVE_CLAUSE(teams_distribute_parallel_for_simd, 1, ~0, dist_schedule)
__OMP_DIRECTIVE_CLAUSE(teams_distribute_parallel_for_simd, 1, ~0, if)
__OMP_DIRECTIVE_CLAUSE(teams_distribute_parallel_for_simd, 1, ~0, num_threads)
__OMP_DIRECTIVE_CLAUSE(teams_distribute_parallel_for_simd, 1, ~0, default)
__OMP_DIRECTIVE_CLAUSE(teams_distribute_parallel_for_simd, 1, ~0, proc_bind)
__OMP_DIRECTIVE_CLAUSE(teams_distribute_parallel_for_simd, 1, ~0, private)
__OMP_DIRECTIVE_CLAUSE(teams_distribute_parallel_for_simd, 1, ~0, shared)
__OMP_DIRECTIVE_CLAUSE(teams_distribute_parallel_for_simd, 1, ~0, reduction)
__OMP_DIRECTIVE_CLAUSE(teams_distribute_parallel_for_simd, 1, ~0, schedule)
__OMP_DIRECTIVE_CLAUSE(teams_distribute_parallel_for_simd, 1, ~0, linear)
__OMP_DIRECTIVE_CLAUSE(teams_distribute_parallel_for_simd, 1, ~0, aligned)
__OMP_DIRECTIVE_CLAUSE(teams_distribute_parallel_for_simd, 1, ~0, safelen)
__OMP_DIRECTIVE_CLAUSE(teams_distribute_parallel_for_simd, 1, ~0, simdlen)
__OMP_DIRECTIVE_CLAUSE(teams_distribute_parallel_for_simd, 1, ~0, num_teams)
__OMP_DIRECTIVE_CLAUSE(teams_distribute_parallel_for_simd, 1, ~0, thread_limit)
__OMP_DIRECTIVE_CLAUSE(teams_distribute_parallel_for_simd, 1, ~0, allocate)
__OMP_DIRECTIVE_CLAUSE(teams_distribute_parallel_for_simd, 50, ~0, nontemporal)
__OMP_DIRECTIVE_CLAUSE(teams_distribute_parallel_for_simd, 50, ~0, order)
__OMP_DIRECTIVE_CLAUSE(teams_distribute_parallel_for, 1, ~0, firstprivate)
__OMP_DIRECTIVE_CLAUSE(teams_distribute_parallel_for, 1, ~0, lastprivate)
__OMP_DIRECTIVE_CLAUSE(teams_distribute_parallel_for, 1, ~0, collapse)
__OMP_DIRECTIVE_CLAUSE(teams_distribute_parallel_for, 1, ~0, dist_schedule)
__OMP_DIRECTIVE_CLAUSE(teams_distribute_parallel_for, 1, ~0, if)
__OMP_DIRECTIVE_CLAUSE(teams_distribute_parallel_for, 1, ~0, num_threads)
__OMP_DIRECTIVE_CLAUSE(teams_distribute_parallel_for, 1, ~0, default)
__OMP_DIRECTIVE_CLAUSE(teams_distribute_parallel_for, 1, ~0, proc_bind)
__OMP_DIRECTIVE_CLAUSE(teams_distribute_parallel_for, 1, ~0, private)
__OMP_DIRECTIVE_CLAUSE(teams_distribute_parallel_for, 1, ~0, shared)
__OMP_DIRECTIVE_CLAUSE(teams_distribute_parallel_for, 1, ~0, reduction)
__OMP_DIRECTIVE_CLAUSE(teams_distribute_parallel_for, 1, ~0, schedule)
__OMP_DIRECTIVE_CLAUSE(teams_distribute_parallel_for, 1, ~0, num_teams)
__OMP_DIRECTIVE_CLAUSE(teams_distribute_parallel_for, 1, ~0, thread_limit)
__OMP_DIRECTIVE_CLAUSE(teams_distribute_parallel_for, 1, ~0, copyin)
__OMP_DIRECTIVE_CLAUSE(teams_distribute_parallel_for, 1, ~0, allocate)
__OMP_DIRECTIVE_CLAUSE(teams_distribute_parallel_for, 50, ~0, order)
__OMP_DIRECTIVE_CLAUSE(target_teams, 1, ~0, if)
__OMP_DIRECTIVE_CLAUSE(target_teams, 1, ~0, device)
__OMP_DIRECTIVE_CLAUSE(target_teams, 1, ~0, map)
__OMP_DIRECTIVE_CLAUSE(target_teams, 1, ~0, private)
__OMP_DIRECTIVE_CLAUSE(target_teams, 1, ~0, nowait)
__OMP_DIRECTIVE_CLAUSE(target_teams, 1, ~0, depend)
__OMP_DIRECTIVE_CLAUSE(target_teams, 1, ~0, defaultmap)
__OMP_DIRECTIVE_CLAUSE(target_teams, 1, ~0, firstprivate)
__OMP_DIRECTIVE_CLAUSE(target_teams, 1, ~0, is_device_ptr)
__OMP_DIRECTIVE_CLAUSE(target_teams, 1, ~0, default)
__OMP_DIRECTIVE_CLAUSE(target_teams, 1, ~0, shared)
__OMP_DIRECTIVE_CLAUSE(target_teams, 1, ~0, reduction)
__OMP_DIRECTIVE_CLAUSE(target_teams, 1, ~0, num_teams)
__OMP_DIRECTIVE_CLAUSE(target_teams, 1, ~0, thread_limit)
__OMP_DIRECTIVE_CLAUSE(target_teams, 1, ~0, allocate)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute, 1, ~0, if)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute, 1, ~0, device)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute, 1, ~0, map)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute, 1, ~0, private)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute, 1, ~0, nowait)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute, 1, ~0, depend)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute, 1, ~0, defaultmap)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute, 1, ~0, firstprivate)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute, 1, ~0, is_device_ptr)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute, 1, ~0, default)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute, 1, ~0, shared)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute, 1, ~0, reduction)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute, 1, ~0, num_teams)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute, 1, ~0, thread_limit)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute, 1, ~0, lastprivate)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute, 1, ~0, collapse)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute, 1, ~0, dist_schedule)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute, 1, ~0, allocate)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_parallel_for, 1, ~0, if)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_parallel_for, 1, ~0, device)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_parallel_for, 1, ~0, map)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_parallel_for, 1, ~0, private)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_parallel_for, 1, ~0, nowait)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_parallel_for, 1, ~0, depend)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_parallel_for, 1, ~0, defaultmap)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_parallel_for, 1, ~0,
firstprivate)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_parallel_for, 1, ~0,
is_device_ptr)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_parallel_for, 1, ~0, default)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_parallel_for, 1, ~0, shared)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_parallel_for, 1, ~0, reduction)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_parallel_for, 1, ~0, num_teams)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_parallel_for, 1, ~0,
thread_limit)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_parallel_for, 1, ~0, lastprivate)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_parallel_for, 1, ~0, collapse)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_parallel_for, 1, ~0,
dist_schedule)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_parallel_for, 1, ~0, num_threads)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_parallel_for, 1, ~0, proc_bind)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_parallel_for, 1, ~0, schedule)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_parallel_for, 1, ~0, allocate)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_parallel_for, 50, ~0, order)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_parallel_for_simd, 1, ~0, if)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_parallel_for_simd, 1, ~0, device)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_parallel_for_simd, 1, ~0, map)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_parallel_for_simd, 1, ~0,
private)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_parallel_for_simd, 1, ~0, nowait)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_parallel_for_simd, 1, ~0, depend)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_parallel_for_simd, 1, ~0,
defaultmap)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_parallel_for_simd, 1, ~0,
firstprivate)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_parallel_for_simd, 1, ~0,
is_device_ptr)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_parallel_for_simd, 1, ~0,
default)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_parallel_for_simd, 1, ~0, shared)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_parallel_for_simd, 1, ~0,
reduction)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_parallel_for_simd, 1, ~0,
num_teams)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_parallel_for_simd, 1, ~0,
thread_limit)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_parallel_for_simd, 1, ~0,
lastprivate)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_parallel_for_simd, 1, ~0,
collapse)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_parallel_for_simd, 1, ~0,
dist_schedule)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_parallel_for_simd, 1, ~0,
num_threads)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_parallel_for_simd, 1, ~0,
proc_bind)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_parallel_for_simd, 1, ~0,
schedule)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_parallel_for_simd, 1, ~0, linear)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_parallel_for_simd, 1, ~0,
aligned)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_parallel_for_simd, 1, ~0,
safelen)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_parallel_for_simd, 1, ~0,
simdlen)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_parallel_for_simd, 1, ~0,
allocate)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_parallel_for_simd, 50, ~0,
nontemporal)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_parallel_for_simd, 50, ~0, order)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_simd, 1, ~0, if)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_simd, 1, ~0, device)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_simd, 1, ~0, map)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_simd, 1, ~0, private)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_simd, 1, ~0, nowait)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_simd, 1, ~0, depend)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_simd, 1, ~0, defaultmap)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_simd, 1, ~0, firstprivate)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_simd, 1, ~0, lastprivate)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_simd, 1, ~0, is_device_ptr)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_simd, 1, ~0, shared)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_simd, 1, ~0, reduction)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_simd, 1, ~0, num_teams)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_simd, 1, ~0, thread_limit)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_simd, 1, ~0, collapse)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_simd, 1, ~0, dist_schedule)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_simd, 1, ~0, linear)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_simd, 1, ~0, aligned)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_simd, 1, ~0, safelen)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_simd, 1, ~0, simdlen)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_simd, 1, ~0, allocate)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_simd, 50, ~0, nontemporal)
__OMP_DIRECTIVE_CLAUSE(target_teams_distribute_simd, 50, ~0, order)
__OMP_DIRECTIVE_CLAUSE(taskgroup, 1, ~0, task_reduction)
__OMP_DIRECTIVE_CLAUSE(taskgroup, 1, ~0, allocate)
__OMP_DIRECTIVE_CLAUSE(declare_mapper, 1, ~0, map)
__OMP_DIRECTIVE_CLAUSE(declare_variant, 1, ~0, match)
__OMP_DIRECTIVE_CLAUSE(flush, 50, ~0, acq_rel)
__OMP_DIRECTIVE_CLAUSE(flush, 50, ~0, acquire)
__OMP_DIRECTIVE_CLAUSE(flush, 50, ~0, release)
// TODO This should ne `none` instead
__OMP_DIRECTIVE_CLAUSE(flush, 1, ~0, flush)
__OMP_DIRECTIVE_CLAUSE(depobj, 50, ~0, depend)
__OMP_DIRECTIVE_CLAUSE(depobj, 50, ~0, destroy)
__OMP_DIRECTIVE_CLAUSE(depobj, 50, ~0, update)
// TODO This should ne `none` instead
__OMP_DIRECTIVE_CLAUSE(depobj, 50, ~0, depobj)
#undef __OMP_DIRECTIVE_CLAUSE
#undef OMP_DIRECTIVE_CLAUSE
///}

11
llvm/lib/Frontend/OpenMP/OMPConstants.cpp
View File

@ -54,6 +54,17 @@ StringRef llvm::omp::getOpenMPClauseName(Clause C) {
llvm_unreachable("Invalid OpenMP clause kind");
}
bool llvm::omp::isAllowedClauseForDirective(Directive D, Clause C,
unsigned Version) {
assert(unsigned(D) <= unsigned(OMPD_unknown));
assert(unsigned(C) <= unsigned(OMPC_unknown));
#define OMP_DIRECTIVE_CLAUSE(Dir, MinVersion, MaxVersion, Cl) \
if (D == Dir && C == Cl && MinVersion <= Version && MaxVersion >= Version) \
return true;
#include "llvm/Frontend/OpenMP/OMPKinds.def"
return false;
}
/// Declarations for LLVM-IR types (simple, array, function and structure) are
/// generated below. Their names are defined and used in OpenMPKinds.def. Here
/// we provide the declarations, the initializeTypes function will provide the