Update prebuilt Clang to r416183b from Android.
https://android.googlesource.com/platform/prebuilts/clang/host/
linux-x86/+/06a71ddac05c22edb2d10b590e1769b3f8619bef
clang 12.0.5 (based on r416183b) from build 7284624.
Change-Id: I277a316abcf47307562d8b748b84870f31a72866
Signed-off-by: Olivier Deprez <olivier.deprez@arm.com>
diff --git a/linux-x64/clang/include/llvm/Frontend/Directive/DirectiveBase.td b/linux-x64/clang/include/llvm/Frontend/Directive/DirectiveBase.td
new file mode 100644
index 0000000..164559d
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Frontend/Directive/DirectiveBase.td
@@ -0,0 +1,152 @@
+//===-- DirectiveBase.td - Base directive definition file --*- tablegen -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This is the base definition file directives and clauses.
+//
+//===----------------------------------------------------------------------===//
+
+
+// General information about the directive language.
+class DirectiveLanguage {
+ // Name of the directive language such as omp or acc.
+ string name = ?;
+
+ // The C++ namespace that code of this directive language should be placed
+ // into. This namespace is nested in llvm namespace.
+ //
+ // By default, uses the name of the directive language as the only namespace.
+ // To avoid placing in any namespace, use "". To specify nested namespaces,
+ // use "::" as the delimiter, e.g., given "A::B", ops will be placed in
+ // `namespace A { namespace B { <directives-clauses> } }`.
+ string cppNamespace = name;
+
+ // Optional prefix used for the generation of the enumerator in the Directive
+ // enum.
+ string directivePrefix = "";
+
+ // Optional prefix used for the generation of the enumerator in the Clause
+ // enum.
+ string clausePrefix = "";
+
+ // Make the enum values available in the namespace. This allows us to
+ // write something like Enum_X if we have a `using namespace cppNamespace`.
+ bit makeEnumAvailableInNamespace = false;
+
+ // Generate include and macro to enable LLVM BitmaskEnum.
+ bit enableBitmaskEnumInNamespace = false;
+
+ // Header file included in the implementation code generated. Ususally the
+ // output file of the declaration code generation. Can be left blank.
+ string includeHeader = "";
+
+ // EnumSet class name used for clauses to generated the allowed clauses map.
+ string clauseEnumSetClass = "";
+
+ // Class holding the clauses in the flang parse-tree.
+ string flangClauseBaseClass = "";
+}
+
+// Information about values accepted by enum-like clauses
+class ClauseVal<string n, int v, bit uv> {
+ // Name of the clause value.
+ string name = n;
+
+ // Integer value of the clause.
+ int value = v;
+
+ // Can user specify this value?
+ bit isUserValue = uv;
+
+ // Set clause value used by default when unknown.
+ bit isDefault = false;
+}
+
+// Information about a specific clause.
+class Clause<string c> {
+ // Name of the clause.
+ string name = c;
+
+ // Define an alternative name return in get<LanguageName>ClauseName function.
+ string alternativeName = "";
+
+ // Optional class holding value of the clause in clang AST.
+ string clangClass = "";
+
+ // Optional class holding the clause in flang AST. If left blank, the class
+ // is assumed to be the name of the clause with capitalized word and
+ // underscores removed.
+ // ex: async -> Async
+ // num_threads -> NumThreads
+ string flangClass = "";
+
+ // Optional class holding value of the clause in flang AST.
+ string flangClassValue = "";
+
+ // If set to true, value is optional. Not optional by default.
+ bit isValueOptional = false;
+
+ // Name of enum when there is a list of allowed clause values.
+ string enumClauseValue = "";
+
+ // List of allowed clause values
+ list<ClauseVal> allowedClauseValues = [];
+ // If set to true, value class is part of a list. Single class by default.
+ bit isValueList = false;
+
+ // Define a default value such as "*".
+ string defaultValue = "";
+
+ // Is clause implicit? If clause is set as implicit, the default kind will
+ // be return in get<LanguageName>ClauseKind instead of their own kind.
+ bit isImplicit = false;
+
+ // Set clause used by default when unknown. Function returning the kind
+ // of enumeration will use this clause as the default.
+ bit isDefault = false;
+}
+
+// Hold information about clause validity by version.
+class VersionedClause<Clause c, int min = 1, int max = 0x7FFFFFFF> {
+ // Actual clause.
+ Clause clause = c;
+
+ // Mininum version number where this clause is valid.
+ int minVersion = min;
+
+ // Maximum version number where this clause is valid.
+ int maxVersion = max;
+}
+
+// Information about a specific directive.
+class Directive<string d> {
+ // Name of the directive. Can be composite directive sepearted by whitespace.
+ string name = d;
+
+ // Define an alternative name return in get<LanguageName>DirectiveName
+ // function.
+ string alternativeName = "";
+
+ // Clauses cannot appear twice in the three allowed lists below. Also, since
+ // required implies allowed, the same clause cannot appear in both the
+ // allowedClauses and requiredClauses lists.
+
+ // List of allowed clauses for the directive.
+ list<VersionedClause> allowedClauses = [];
+
+ // List of clauses that are allowed to appear only once.
+ list<VersionedClause> allowedOnceClauses = [];
+
+ // List of clauses that are allowed but mutually exclusive.
+ list<VersionedClause> allowedExclusiveClauses = [];
+
+ // List of clauses that are required.
+ list<VersionedClause> requiredClauses = [];
+
+ // Set directive used by default when unknown.
+ bit isDefault = false;
+}
diff --git a/linux-x64/clang/include/llvm/Frontend/OpenACC/ACC.h.inc b/linux-x64/clang/include/llvm/Frontend/OpenACC/ACC.h.inc
new file mode 100644
index 0000000..badccfb
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Frontend/OpenACC/ACC.h.inc
@@ -0,0 +1,181 @@
+#ifndef LLVM_OpenACC_INC
+#define LLVM_OpenACC_INC
+
+#include "llvm/ADT/BitmaskEnum.h"
+
+namespace llvm {
+class StringRef;
+namespace acc {
+
+LLVM_ENABLE_BITMASK_ENUMS_IN_NAMESPACE();
+
+enum class Directive {
+ ACCD_atomic,
+ ACCD_cache,
+ ACCD_data,
+ ACCD_declare,
+ ACCD_enter_data,
+ ACCD_exit_data,
+ ACCD_host_data,
+ ACCD_init,
+ ACCD_kernels,
+ ACCD_kernels_loop,
+ ACCD_loop,
+ ACCD_parallel,
+ ACCD_parallel_loop,
+ ACCD_routine,
+ ACCD_serial,
+ ACCD_serial_loop,
+ ACCD_set,
+ ACCD_shutdown,
+ ACCD_unknown,
+ ACCD_update,
+ ACCD_wait,
+};
+
+static constexpr std::size_t Directive_enumSize = 21;
+
+constexpr auto ACCD_atomic = llvm::acc::Directive::ACCD_atomic;
+constexpr auto ACCD_cache = llvm::acc::Directive::ACCD_cache;
+constexpr auto ACCD_data = llvm::acc::Directive::ACCD_data;
+constexpr auto ACCD_declare = llvm::acc::Directive::ACCD_declare;
+constexpr auto ACCD_enter_data = llvm::acc::Directive::ACCD_enter_data;
+constexpr auto ACCD_exit_data = llvm::acc::Directive::ACCD_exit_data;
+constexpr auto ACCD_host_data = llvm::acc::Directive::ACCD_host_data;
+constexpr auto ACCD_init = llvm::acc::Directive::ACCD_init;
+constexpr auto ACCD_kernels = llvm::acc::Directive::ACCD_kernels;
+constexpr auto ACCD_kernels_loop = llvm::acc::Directive::ACCD_kernels_loop;
+constexpr auto ACCD_loop = llvm::acc::Directive::ACCD_loop;
+constexpr auto ACCD_parallel = llvm::acc::Directive::ACCD_parallel;
+constexpr auto ACCD_parallel_loop = llvm::acc::Directive::ACCD_parallel_loop;
+constexpr auto ACCD_routine = llvm::acc::Directive::ACCD_routine;
+constexpr auto ACCD_serial = llvm::acc::Directive::ACCD_serial;
+constexpr auto ACCD_serial_loop = llvm::acc::Directive::ACCD_serial_loop;
+constexpr auto ACCD_set = llvm::acc::Directive::ACCD_set;
+constexpr auto ACCD_shutdown = llvm::acc::Directive::ACCD_shutdown;
+constexpr auto ACCD_unknown = llvm::acc::Directive::ACCD_unknown;
+constexpr auto ACCD_update = llvm::acc::Directive::ACCD_update;
+constexpr auto ACCD_wait = llvm::acc::Directive::ACCD_wait;
+
+enum class Clause {
+ ACCC_async,
+ ACCC_attach,
+ ACCC_auto,
+ ACCC_bind,
+ ACCC_capture,
+ ACCC_collapse,
+ ACCC_copy,
+ ACCC_copyin,
+ ACCC_copyout,
+ ACCC_create,
+ ACCC_default,
+ ACCC_default_async,
+ ACCC_delete,
+ ACCC_detach,
+ ACCC_device,
+ ACCC_device_num,
+ ACCC_deviceptr,
+ ACCC_device_resident,
+ ACCC_device_type,
+ ACCC_finalize,
+ ACCC_firstprivate,
+ ACCC_gang,
+ ACCC_host,
+ ACCC_if,
+ ACCC_if_present,
+ ACCC_independent,
+ ACCC_link,
+ ACCC_no_create,
+ ACCC_nohost,
+ ACCC_num_gangs,
+ ACCC_num_workers,
+ ACCC_present,
+ ACCC_private,
+ ACCC_read,
+ ACCC_reduction,
+ ACCC_self,
+ ACCC_seq,
+ ACCC_tile,
+ ACCC_unknown,
+ ACCC_use_device,
+ ACCC_vector,
+ ACCC_vector_length,
+ ACCC_wait,
+ ACCC_worker,
+ ACCC_write,
+};
+
+static constexpr std::size_t Clause_enumSize = 45;
+
+constexpr auto ACCC_async = llvm::acc::Clause::ACCC_async;
+constexpr auto ACCC_attach = llvm::acc::Clause::ACCC_attach;
+constexpr auto ACCC_auto = llvm::acc::Clause::ACCC_auto;
+constexpr auto ACCC_bind = llvm::acc::Clause::ACCC_bind;
+constexpr auto ACCC_capture = llvm::acc::Clause::ACCC_capture;
+constexpr auto ACCC_collapse = llvm::acc::Clause::ACCC_collapse;
+constexpr auto ACCC_copy = llvm::acc::Clause::ACCC_copy;
+constexpr auto ACCC_copyin = llvm::acc::Clause::ACCC_copyin;
+constexpr auto ACCC_copyout = llvm::acc::Clause::ACCC_copyout;
+constexpr auto ACCC_create = llvm::acc::Clause::ACCC_create;
+constexpr auto ACCC_default = llvm::acc::Clause::ACCC_default;
+constexpr auto ACCC_default_async = llvm::acc::Clause::ACCC_default_async;
+constexpr auto ACCC_delete = llvm::acc::Clause::ACCC_delete;
+constexpr auto ACCC_detach = llvm::acc::Clause::ACCC_detach;
+constexpr auto ACCC_device = llvm::acc::Clause::ACCC_device;
+constexpr auto ACCC_device_num = llvm::acc::Clause::ACCC_device_num;
+constexpr auto ACCC_deviceptr = llvm::acc::Clause::ACCC_deviceptr;
+constexpr auto ACCC_device_resident = llvm::acc::Clause::ACCC_device_resident;
+constexpr auto ACCC_device_type = llvm::acc::Clause::ACCC_device_type;
+constexpr auto ACCC_finalize = llvm::acc::Clause::ACCC_finalize;
+constexpr auto ACCC_firstprivate = llvm::acc::Clause::ACCC_firstprivate;
+constexpr auto ACCC_gang = llvm::acc::Clause::ACCC_gang;
+constexpr auto ACCC_host = llvm::acc::Clause::ACCC_host;
+constexpr auto ACCC_if = llvm::acc::Clause::ACCC_if;
+constexpr auto ACCC_if_present = llvm::acc::Clause::ACCC_if_present;
+constexpr auto ACCC_independent = llvm::acc::Clause::ACCC_independent;
+constexpr auto ACCC_link = llvm::acc::Clause::ACCC_link;
+constexpr auto ACCC_no_create = llvm::acc::Clause::ACCC_no_create;
+constexpr auto ACCC_nohost = llvm::acc::Clause::ACCC_nohost;
+constexpr auto ACCC_num_gangs = llvm::acc::Clause::ACCC_num_gangs;
+constexpr auto ACCC_num_workers = llvm::acc::Clause::ACCC_num_workers;
+constexpr auto ACCC_present = llvm::acc::Clause::ACCC_present;
+constexpr auto ACCC_private = llvm::acc::Clause::ACCC_private;
+constexpr auto ACCC_read = llvm::acc::Clause::ACCC_read;
+constexpr auto ACCC_reduction = llvm::acc::Clause::ACCC_reduction;
+constexpr auto ACCC_self = llvm::acc::Clause::ACCC_self;
+constexpr auto ACCC_seq = llvm::acc::Clause::ACCC_seq;
+constexpr auto ACCC_tile = llvm::acc::Clause::ACCC_tile;
+constexpr auto ACCC_unknown = llvm::acc::Clause::ACCC_unknown;
+constexpr auto ACCC_use_device = llvm::acc::Clause::ACCC_use_device;
+constexpr auto ACCC_vector = llvm::acc::Clause::ACCC_vector;
+constexpr auto ACCC_vector_length = llvm::acc::Clause::ACCC_vector_length;
+constexpr auto ACCC_wait = llvm::acc::Clause::ACCC_wait;
+constexpr auto ACCC_worker = llvm::acc::Clause::ACCC_worker;
+constexpr auto ACCC_write = llvm::acc::Clause::ACCC_write;
+
+enum class DefaultValue {
+ ACC_Default_present=0,
+ ACC_Default_none=1,
+};
+
+constexpr auto ACC_Default_present = llvm::acc::DefaultValue::ACC_Default_present;
+constexpr auto ACC_Default_none = llvm::acc::DefaultValue::ACC_Default_none;
+
+// Enumeration helper functions
+Directive getOpenACCDirectiveKind(llvm::StringRef Str);
+
+llvm::StringRef getOpenACCDirectiveName(Directive D);
+
+Clause getOpenACCClauseKind(llvm::StringRef Str);
+
+llvm::StringRef getOpenACCClauseName(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);
+
+DefaultValue getDefaultValue(StringRef);
+llvm::StringRef getOpenACCDefaultValueName(DefaultValue);
+
+} // namespace acc
+} // namespace llvm
+#endif // LLVM_OpenACC_INC
diff --git a/linux-x64/clang/include/llvm/Frontend/OpenACC/ACC.inc b/linux-x64/clang/include/llvm/Frontend/OpenACC/ACC.inc
new file mode 100644
index 0000000..e897fa9
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Frontend/OpenACC/ACC.inc
@@ -0,0 +1,1143 @@
+#ifdef GEN_FLANG_DIRECTIVE_CLAUSE_SETS
+#undef GEN_FLANG_DIRECTIVE_CLAUSE_SETS
+
+namespace llvm {
+namespace acc {
+
+ // Sets for atomic
+
+ static AccClauseSet allowedClauses_ACCD_atomic {
+ };
+
+ static AccClauseSet allowedOnceClauses_ACCD_atomic {
+ };
+
+ static AccClauseSet allowedExclusiveClauses_ACCD_atomic {
+ };
+
+ static AccClauseSet requiredClauses_ACCD_atomic {
+ };
+
+ // Sets for cache
+
+ static AccClauseSet allowedClauses_ACCD_cache {
+ };
+
+ static AccClauseSet allowedOnceClauses_ACCD_cache {
+ };
+
+ static AccClauseSet allowedExclusiveClauses_ACCD_cache {
+ };
+
+ static AccClauseSet requiredClauses_ACCD_cache {
+ };
+
+ // Sets for data
+
+ static AccClauseSet allowedClauses_ACCD_data {
+ };
+
+ static AccClauseSet allowedOnceClauses_ACCD_data {
+ llvm::acc::Clause::ACCC_if,
+ llvm::acc::Clause::ACCC_default,
+ };
+
+ static AccClauseSet allowedExclusiveClauses_ACCD_data {
+ };
+
+ static AccClauseSet requiredClauses_ACCD_data {
+ llvm::acc::Clause::ACCC_attach,
+ llvm::acc::Clause::ACCC_copy,
+ llvm::acc::Clause::ACCC_copyin,
+ llvm::acc::Clause::ACCC_copyout,
+ llvm::acc::Clause::ACCC_create,
+ llvm::acc::Clause::ACCC_default,
+ llvm::acc::Clause::ACCC_deviceptr,
+ llvm::acc::Clause::ACCC_no_create,
+ llvm::acc::Clause::ACCC_present,
+ };
+
+ // Sets for declare
+
+ static AccClauseSet allowedClauses_ACCD_declare {
+ llvm::acc::Clause::ACCC_copy,
+ llvm::acc::Clause::ACCC_copyin,
+ llvm::acc::Clause::ACCC_copyout,
+ llvm::acc::Clause::ACCC_create,
+ llvm::acc::Clause::ACCC_present,
+ llvm::acc::Clause::ACCC_deviceptr,
+ llvm::acc::Clause::ACCC_device_resident,
+ llvm::acc::Clause::ACCC_link,
+ };
+
+ static AccClauseSet allowedOnceClauses_ACCD_declare {
+ };
+
+ static AccClauseSet allowedExclusiveClauses_ACCD_declare {
+ };
+
+ static AccClauseSet requiredClauses_ACCD_declare {
+ };
+
+ // Sets for enter data
+
+ static AccClauseSet allowedClauses_ACCD_enter_data {
+ };
+
+ static AccClauseSet allowedOnceClauses_ACCD_enter_data {
+ llvm::acc::Clause::ACCC_async,
+ llvm::acc::Clause::ACCC_if,
+ llvm::acc::Clause::ACCC_wait,
+ };
+
+ static AccClauseSet allowedExclusiveClauses_ACCD_enter_data {
+ };
+
+ static AccClauseSet requiredClauses_ACCD_enter_data {
+ llvm::acc::Clause::ACCC_attach,
+ llvm::acc::Clause::ACCC_create,
+ llvm::acc::Clause::ACCC_copyin,
+ };
+
+ // Sets for exit data
+
+ static AccClauseSet allowedClauses_ACCD_exit_data {
+ llvm::acc::Clause::ACCC_async,
+ llvm::acc::Clause::ACCC_if,
+ llvm::acc::Clause::ACCC_wait,
+ llvm::acc::Clause::ACCC_finalize,
+ };
+
+ static AccClauseSet allowedOnceClauses_ACCD_exit_data {
+ };
+
+ static AccClauseSet allowedExclusiveClauses_ACCD_exit_data {
+ };
+
+ static AccClauseSet requiredClauses_ACCD_exit_data {
+ llvm::acc::Clause::ACCC_copyout,
+ llvm::acc::Clause::ACCC_delete,
+ llvm::acc::Clause::ACCC_detach,
+ };
+
+ // Sets for host_data
+
+ static AccClauseSet allowedClauses_ACCD_host_data {
+ llvm::acc::Clause::ACCC_if,
+ llvm::acc::Clause::ACCC_if_present,
+ };
+
+ static AccClauseSet allowedOnceClauses_ACCD_host_data {
+ };
+
+ static AccClauseSet allowedExclusiveClauses_ACCD_host_data {
+ };
+
+ static AccClauseSet requiredClauses_ACCD_host_data {
+ llvm::acc::Clause::ACCC_use_device,
+ };
+
+ // Sets for init
+
+ static AccClauseSet allowedClauses_ACCD_init {
+ };
+
+ static AccClauseSet allowedOnceClauses_ACCD_init {
+ llvm::acc::Clause::ACCC_device_num,
+ llvm::acc::Clause::ACCC_device_type,
+ llvm::acc::Clause::ACCC_if,
+ };
+
+ static AccClauseSet allowedExclusiveClauses_ACCD_init {
+ };
+
+ static AccClauseSet requiredClauses_ACCD_init {
+ };
+
+ // Sets for kernels
+
+ static AccClauseSet allowedClauses_ACCD_kernels {
+ llvm::acc::Clause::ACCC_attach,
+ llvm::acc::Clause::ACCC_copy,
+ llvm::acc::Clause::ACCC_copyin,
+ llvm::acc::Clause::ACCC_copyout,
+ llvm::acc::Clause::ACCC_create,
+ llvm::acc::Clause::ACCC_device_type,
+ llvm::acc::Clause::ACCC_no_create,
+ llvm::acc::Clause::ACCC_present,
+ llvm::acc::Clause::ACCC_deviceptr,
+ llvm::acc::Clause::ACCC_wait,
+ };
+
+ static AccClauseSet allowedOnceClauses_ACCD_kernels {
+ llvm::acc::Clause::ACCC_async,
+ llvm::acc::Clause::ACCC_default,
+ llvm::acc::Clause::ACCC_if,
+ llvm::acc::Clause::ACCC_num_gangs,
+ llvm::acc::Clause::ACCC_num_workers,
+ llvm::acc::Clause::ACCC_self,
+ llvm::acc::Clause::ACCC_vector_length,
+ };
+
+ static AccClauseSet allowedExclusiveClauses_ACCD_kernels {
+ };
+
+ static AccClauseSet requiredClauses_ACCD_kernels {
+ };
+
+ // Sets for kernels loop
+
+ static AccClauseSet allowedClauses_ACCD_kernels_loop {
+ llvm::acc::Clause::ACCC_copy,
+ llvm::acc::Clause::ACCC_copyin,
+ llvm::acc::Clause::ACCC_copyout,
+ llvm::acc::Clause::ACCC_create,
+ llvm::acc::Clause::ACCC_device_type,
+ llvm::acc::Clause::ACCC_no_create,
+ llvm::acc::Clause::ACCC_present,
+ llvm::acc::Clause::ACCC_private,
+ llvm::acc::Clause::ACCC_deviceptr,
+ llvm::acc::Clause::ACCC_attach,
+ };
+
+ static AccClauseSet allowedOnceClauses_ACCD_kernels_loop {
+ llvm::acc::Clause::ACCC_async,
+ llvm::acc::Clause::ACCC_collapse,
+ llvm::acc::Clause::ACCC_default,
+ llvm::acc::Clause::ACCC_gang,
+ llvm::acc::Clause::ACCC_if,
+ llvm::acc::Clause::ACCC_num_gangs,
+ llvm::acc::Clause::ACCC_num_workers,
+ llvm::acc::Clause::ACCC_reduction,
+ llvm::acc::Clause::ACCC_self,
+ llvm::acc::Clause::ACCC_tile,
+ llvm::acc::Clause::ACCC_vector,
+ llvm::acc::Clause::ACCC_vector_length,
+ llvm::acc::Clause::ACCC_wait,
+ llvm::acc::Clause::ACCC_worker,
+ };
+
+ static AccClauseSet allowedExclusiveClauses_ACCD_kernels_loop {
+ llvm::acc::Clause::ACCC_auto,
+ llvm::acc::Clause::ACCC_independent,
+ llvm::acc::Clause::ACCC_seq,
+ };
+
+ static AccClauseSet requiredClauses_ACCD_kernels_loop {
+ };
+
+ // Sets for loop
+
+ static AccClauseSet allowedClauses_ACCD_loop {
+ llvm::acc::Clause::ACCC_device_type,
+ llvm::acc::Clause::ACCC_private,
+ };
+
+ static AccClauseSet allowedOnceClauses_ACCD_loop {
+ llvm::acc::Clause::ACCC_collapse,
+ llvm::acc::Clause::ACCC_gang,
+ llvm::acc::Clause::ACCC_reduction,
+ llvm::acc::Clause::ACCC_tile,
+ llvm::acc::Clause::ACCC_vector,
+ llvm::acc::Clause::ACCC_worker,
+ };
+
+ static AccClauseSet allowedExclusiveClauses_ACCD_loop {
+ llvm::acc::Clause::ACCC_auto,
+ llvm::acc::Clause::ACCC_independent,
+ llvm::acc::Clause::ACCC_seq,
+ };
+
+ static AccClauseSet requiredClauses_ACCD_loop {
+ };
+
+ // Sets for parallel
+
+ static AccClauseSet allowedClauses_ACCD_parallel {
+ llvm::acc::Clause::ACCC_attach,
+ llvm::acc::Clause::ACCC_copy,
+ llvm::acc::Clause::ACCC_copyin,
+ llvm::acc::Clause::ACCC_copyout,
+ llvm::acc::Clause::ACCC_create,
+ llvm::acc::Clause::ACCC_deviceptr,
+ llvm::acc::Clause::ACCC_device_type,
+ llvm::acc::Clause::ACCC_no_create,
+ llvm::acc::Clause::ACCC_present,
+ llvm::acc::Clause::ACCC_private,
+ llvm::acc::Clause::ACCC_firstprivate,
+ llvm::acc::Clause::ACCC_wait,
+ };
+
+ static AccClauseSet allowedOnceClauses_ACCD_parallel {
+ llvm::acc::Clause::ACCC_async,
+ llvm::acc::Clause::ACCC_default,
+ llvm::acc::Clause::ACCC_if,
+ llvm::acc::Clause::ACCC_num_gangs,
+ llvm::acc::Clause::ACCC_num_workers,
+ llvm::acc::Clause::ACCC_reduction,
+ llvm::acc::Clause::ACCC_self,
+ llvm::acc::Clause::ACCC_vector_length,
+ };
+
+ static AccClauseSet allowedExclusiveClauses_ACCD_parallel {
+ };
+
+ static AccClauseSet requiredClauses_ACCD_parallel {
+ };
+
+ // Sets for parallel loop
+
+ static AccClauseSet allowedClauses_ACCD_parallel_loop {
+ llvm::acc::Clause::ACCC_attach,
+ llvm::acc::Clause::ACCC_copy,
+ llvm::acc::Clause::ACCC_copyin,
+ llvm::acc::Clause::ACCC_copyout,
+ llvm::acc::Clause::ACCC_create,
+ llvm::acc::Clause::ACCC_deviceptr,
+ llvm::acc::Clause::ACCC_device_type,
+ llvm::acc::Clause::ACCC_firstprivate,
+ llvm::acc::Clause::ACCC_no_create,
+ llvm::acc::Clause::ACCC_present,
+ llvm::acc::Clause::ACCC_private,
+ llvm::acc::Clause::ACCC_tile,
+ llvm::acc::Clause::ACCC_wait,
+ };
+
+ static AccClauseSet allowedOnceClauses_ACCD_parallel_loop {
+ llvm::acc::Clause::ACCC_async,
+ llvm::acc::Clause::ACCC_collapse,
+ llvm::acc::Clause::ACCC_default,
+ llvm::acc::Clause::ACCC_gang,
+ llvm::acc::Clause::ACCC_if,
+ llvm::acc::Clause::ACCC_num_gangs,
+ llvm::acc::Clause::ACCC_num_workers,
+ llvm::acc::Clause::ACCC_reduction,
+ llvm::acc::Clause::ACCC_self,
+ llvm::acc::Clause::ACCC_vector,
+ llvm::acc::Clause::ACCC_vector_length,
+ llvm::acc::Clause::ACCC_worker,
+ };
+
+ static AccClauseSet allowedExclusiveClauses_ACCD_parallel_loop {
+ llvm::acc::Clause::ACCC_auto,
+ llvm::acc::Clause::ACCC_independent,
+ llvm::acc::Clause::ACCC_seq,
+ };
+
+ static AccClauseSet requiredClauses_ACCD_parallel_loop {
+ };
+
+ // Sets for routine
+
+ static AccClauseSet allowedClauses_ACCD_routine {
+ };
+
+ static AccClauseSet allowedOnceClauses_ACCD_routine {
+ llvm::acc::Clause::ACCC_bind,
+ llvm::acc::Clause::ACCC_device_type,
+ llvm::acc::Clause::ACCC_nohost,
+ };
+
+ static AccClauseSet allowedExclusiveClauses_ACCD_routine {
+ };
+
+ static AccClauseSet requiredClauses_ACCD_routine {
+ llvm::acc::Clause::ACCC_gang,
+ llvm::acc::Clause::ACCC_seq,
+ llvm::acc::Clause::ACCC_vector,
+ llvm::acc::Clause::ACCC_worker,
+ };
+
+ // Sets for serial
+
+ static AccClauseSet allowedClauses_ACCD_serial {
+ llvm::acc::Clause::ACCC_attach,
+ llvm::acc::Clause::ACCC_copy,
+ llvm::acc::Clause::ACCC_copyin,
+ llvm::acc::Clause::ACCC_copyout,
+ llvm::acc::Clause::ACCC_create,
+ llvm::acc::Clause::ACCC_deviceptr,
+ llvm::acc::Clause::ACCC_device_type,
+ llvm::acc::Clause::ACCC_no_create,
+ llvm::acc::Clause::ACCC_present,
+ llvm::acc::Clause::ACCC_private,
+ llvm::acc::Clause::ACCC_firstprivate,
+ llvm::acc::Clause::ACCC_wait,
+ };
+
+ static AccClauseSet allowedOnceClauses_ACCD_serial {
+ llvm::acc::Clause::ACCC_async,
+ llvm::acc::Clause::ACCC_default,
+ llvm::acc::Clause::ACCC_if,
+ llvm::acc::Clause::ACCC_reduction,
+ llvm::acc::Clause::ACCC_self,
+ };
+
+ static AccClauseSet allowedExclusiveClauses_ACCD_serial {
+ };
+
+ static AccClauseSet requiredClauses_ACCD_serial {
+ };
+
+ // Sets for serial loop
+
+ static AccClauseSet allowedClauses_ACCD_serial_loop {
+ llvm::acc::Clause::ACCC_attach,
+ llvm::acc::Clause::ACCC_copy,
+ llvm::acc::Clause::ACCC_copyin,
+ llvm::acc::Clause::ACCC_copyout,
+ llvm::acc::Clause::ACCC_create,
+ llvm::acc::Clause::ACCC_deviceptr,
+ llvm::acc::Clause::ACCC_device_type,
+ llvm::acc::Clause::ACCC_firstprivate,
+ llvm::acc::Clause::ACCC_no_create,
+ llvm::acc::Clause::ACCC_present,
+ llvm::acc::Clause::ACCC_private,
+ llvm::acc::Clause::ACCC_wait,
+ };
+
+ static AccClauseSet allowedOnceClauses_ACCD_serial_loop {
+ llvm::acc::Clause::ACCC_async,
+ llvm::acc::Clause::ACCC_collapse,
+ llvm::acc::Clause::ACCC_default,
+ llvm::acc::Clause::ACCC_gang,
+ llvm::acc::Clause::ACCC_if,
+ llvm::acc::Clause::ACCC_reduction,
+ llvm::acc::Clause::ACCC_self,
+ llvm::acc::Clause::ACCC_tile,
+ llvm::acc::Clause::ACCC_vector,
+ llvm::acc::Clause::ACCC_worker,
+ };
+
+ static AccClauseSet allowedExclusiveClauses_ACCD_serial_loop {
+ llvm::acc::Clause::ACCC_auto,
+ llvm::acc::Clause::ACCC_independent,
+ llvm::acc::Clause::ACCC_seq,
+ };
+
+ static AccClauseSet requiredClauses_ACCD_serial_loop {
+ };
+
+ // Sets for set
+
+ static AccClauseSet allowedClauses_ACCD_set {
+ };
+
+ static AccClauseSet allowedOnceClauses_ACCD_set {
+ llvm::acc::Clause::ACCC_default_async,
+ llvm::acc::Clause::ACCC_device_num,
+ llvm::acc::Clause::ACCC_device_type,
+ llvm::acc::Clause::ACCC_if,
+ };
+
+ static AccClauseSet allowedExclusiveClauses_ACCD_set {
+ };
+
+ static AccClauseSet requiredClauses_ACCD_set {
+ llvm::acc::Clause::ACCC_default_async,
+ llvm::acc::Clause::ACCC_device_num,
+ llvm::acc::Clause::ACCC_device_type,
+ };
+
+ // Sets for shutdown
+
+ static AccClauseSet allowedClauses_ACCD_shutdown {
+ };
+
+ static AccClauseSet allowedOnceClauses_ACCD_shutdown {
+ llvm::acc::Clause::ACCC_device_num,
+ llvm::acc::Clause::ACCC_device_type,
+ llvm::acc::Clause::ACCC_if,
+ };
+
+ static AccClauseSet allowedExclusiveClauses_ACCD_shutdown {
+ };
+
+ static AccClauseSet requiredClauses_ACCD_shutdown {
+ };
+
+ // Sets for unknown
+
+ static AccClauseSet allowedClauses_ACCD_unknown {
+ };
+
+ static AccClauseSet allowedOnceClauses_ACCD_unknown {
+ };
+
+ static AccClauseSet allowedExclusiveClauses_ACCD_unknown {
+ };
+
+ static AccClauseSet requiredClauses_ACCD_unknown {
+ };
+
+ // Sets for update
+
+ static AccClauseSet allowedClauses_ACCD_update {
+ llvm::acc::Clause::ACCC_device_type,
+ llvm::acc::Clause::ACCC_wait,
+ };
+
+ static AccClauseSet allowedOnceClauses_ACCD_update {
+ llvm::acc::Clause::ACCC_async,
+ llvm::acc::Clause::ACCC_if,
+ llvm::acc::Clause::ACCC_if_present,
+ };
+
+ static AccClauseSet allowedExclusiveClauses_ACCD_update {
+ };
+
+ static AccClauseSet requiredClauses_ACCD_update {
+ llvm::acc::Clause::ACCC_device,
+ llvm::acc::Clause::ACCC_host,
+ llvm::acc::Clause::ACCC_self,
+ };
+
+ // Sets for wait
+
+ static AccClauseSet allowedClauses_ACCD_wait {
+ };
+
+ static AccClauseSet allowedOnceClauses_ACCD_wait {
+ llvm::acc::Clause::ACCC_async,
+ llvm::acc::Clause::ACCC_if,
+ };
+
+ static AccClauseSet allowedExclusiveClauses_ACCD_wait {
+ };
+
+ static AccClauseSet requiredClauses_ACCD_wait {
+ };
+} // namespace acc
+} // namespace llvm
+
+#endif // GEN_FLANG_DIRECTIVE_CLAUSE_SETS
+
+#ifdef GEN_FLANG_DIRECTIVE_CLAUSE_MAP
+#undef GEN_FLANG_DIRECTIVE_CLAUSE_MAP
+
+{
+ {llvm::acc::Directive::ACCD_atomic,
+ {
+ llvm::acc::allowedClauses_ACCD_atomic,
+ llvm::acc::allowedOnceClauses_ACCD_atomic,
+ llvm::acc::allowedExclusiveClauses_ACCD_atomic,
+ llvm::acc::requiredClauses_ACCD_atomic,
+ }
+ },
+ {llvm::acc::Directive::ACCD_cache,
+ {
+ llvm::acc::allowedClauses_ACCD_cache,
+ llvm::acc::allowedOnceClauses_ACCD_cache,
+ llvm::acc::allowedExclusiveClauses_ACCD_cache,
+ llvm::acc::requiredClauses_ACCD_cache,
+ }
+ },
+ {llvm::acc::Directive::ACCD_data,
+ {
+ llvm::acc::allowedClauses_ACCD_data,
+ llvm::acc::allowedOnceClauses_ACCD_data,
+ llvm::acc::allowedExclusiveClauses_ACCD_data,
+ llvm::acc::requiredClauses_ACCD_data,
+ }
+ },
+ {llvm::acc::Directive::ACCD_declare,
+ {
+ llvm::acc::allowedClauses_ACCD_declare,
+ llvm::acc::allowedOnceClauses_ACCD_declare,
+ llvm::acc::allowedExclusiveClauses_ACCD_declare,
+ llvm::acc::requiredClauses_ACCD_declare,
+ }
+ },
+ {llvm::acc::Directive::ACCD_enter_data,
+ {
+ llvm::acc::allowedClauses_ACCD_enter_data,
+ llvm::acc::allowedOnceClauses_ACCD_enter_data,
+ llvm::acc::allowedExclusiveClauses_ACCD_enter_data,
+ llvm::acc::requiredClauses_ACCD_enter_data,
+ }
+ },
+ {llvm::acc::Directive::ACCD_exit_data,
+ {
+ llvm::acc::allowedClauses_ACCD_exit_data,
+ llvm::acc::allowedOnceClauses_ACCD_exit_data,
+ llvm::acc::allowedExclusiveClauses_ACCD_exit_data,
+ llvm::acc::requiredClauses_ACCD_exit_data,
+ }
+ },
+ {llvm::acc::Directive::ACCD_host_data,
+ {
+ llvm::acc::allowedClauses_ACCD_host_data,
+ llvm::acc::allowedOnceClauses_ACCD_host_data,
+ llvm::acc::allowedExclusiveClauses_ACCD_host_data,
+ llvm::acc::requiredClauses_ACCD_host_data,
+ }
+ },
+ {llvm::acc::Directive::ACCD_init,
+ {
+ llvm::acc::allowedClauses_ACCD_init,
+ llvm::acc::allowedOnceClauses_ACCD_init,
+ llvm::acc::allowedExclusiveClauses_ACCD_init,
+ llvm::acc::requiredClauses_ACCD_init,
+ }
+ },
+ {llvm::acc::Directive::ACCD_kernels,
+ {
+ llvm::acc::allowedClauses_ACCD_kernels,
+ llvm::acc::allowedOnceClauses_ACCD_kernels,
+ llvm::acc::allowedExclusiveClauses_ACCD_kernels,
+ llvm::acc::requiredClauses_ACCD_kernels,
+ }
+ },
+ {llvm::acc::Directive::ACCD_kernels_loop,
+ {
+ llvm::acc::allowedClauses_ACCD_kernels_loop,
+ llvm::acc::allowedOnceClauses_ACCD_kernels_loop,
+ llvm::acc::allowedExclusiveClauses_ACCD_kernels_loop,
+ llvm::acc::requiredClauses_ACCD_kernels_loop,
+ }
+ },
+ {llvm::acc::Directive::ACCD_loop,
+ {
+ llvm::acc::allowedClauses_ACCD_loop,
+ llvm::acc::allowedOnceClauses_ACCD_loop,
+ llvm::acc::allowedExclusiveClauses_ACCD_loop,
+ llvm::acc::requiredClauses_ACCD_loop,
+ }
+ },
+ {llvm::acc::Directive::ACCD_parallel,
+ {
+ llvm::acc::allowedClauses_ACCD_parallel,
+ llvm::acc::allowedOnceClauses_ACCD_parallel,
+ llvm::acc::allowedExclusiveClauses_ACCD_parallel,
+ llvm::acc::requiredClauses_ACCD_parallel,
+ }
+ },
+ {llvm::acc::Directive::ACCD_parallel_loop,
+ {
+ llvm::acc::allowedClauses_ACCD_parallel_loop,
+ llvm::acc::allowedOnceClauses_ACCD_parallel_loop,
+ llvm::acc::allowedExclusiveClauses_ACCD_parallel_loop,
+ llvm::acc::requiredClauses_ACCD_parallel_loop,
+ }
+ },
+ {llvm::acc::Directive::ACCD_routine,
+ {
+ llvm::acc::allowedClauses_ACCD_routine,
+ llvm::acc::allowedOnceClauses_ACCD_routine,
+ llvm::acc::allowedExclusiveClauses_ACCD_routine,
+ llvm::acc::requiredClauses_ACCD_routine,
+ }
+ },
+ {llvm::acc::Directive::ACCD_serial,
+ {
+ llvm::acc::allowedClauses_ACCD_serial,
+ llvm::acc::allowedOnceClauses_ACCD_serial,
+ llvm::acc::allowedExclusiveClauses_ACCD_serial,
+ llvm::acc::requiredClauses_ACCD_serial,
+ }
+ },
+ {llvm::acc::Directive::ACCD_serial_loop,
+ {
+ llvm::acc::allowedClauses_ACCD_serial_loop,
+ llvm::acc::allowedOnceClauses_ACCD_serial_loop,
+ llvm::acc::allowedExclusiveClauses_ACCD_serial_loop,
+ llvm::acc::requiredClauses_ACCD_serial_loop,
+ }
+ },
+ {llvm::acc::Directive::ACCD_set,
+ {
+ llvm::acc::allowedClauses_ACCD_set,
+ llvm::acc::allowedOnceClauses_ACCD_set,
+ llvm::acc::allowedExclusiveClauses_ACCD_set,
+ llvm::acc::requiredClauses_ACCD_set,
+ }
+ },
+ {llvm::acc::Directive::ACCD_shutdown,
+ {
+ llvm::acc::allowedClauses_ACCD_shutdown,
+ llvm::acc::allowedOnceClauses_ACCD_shutdown,
+ llvm::acc::allowedExclusiveClauses_ACCD_shutdown,
+ llvm::acc::requiredClauses_ACCD_shutdown,
+ }
+ },
+ {llvm::acc::Directive::ACCD_unknown,
+ {
+ llvm::acc::allowedClauses_ACCD_unknown,
+ llvm::acc::allowedOnceClauses_ACCD_unknown,
+ llvm::acc::allowedExclusiveClauses_ACCD_unknown,
+ llvm::acc::requiredClauses_ACCD_unknown,
+ }
+ },
+ {llvm::acc::Directive::ACCD_update,
+ {
+ llvm::acc::allowedClauses_ACCD_update,
+ llvm::acc::allowedOnceClauses_ACCD_update,
+ llvm::acc::allowedExclusiveClauses_ACCD_update,
+ llvm::acc::requiredClauses_ACCD_update,
+ }
+ },
+ {llvm::acc::Directive::ACCD_wait,
+ {
+ llvm::acc::allowedClauses_ACCD_wait,
+ llvm::acc::allowedOnceClauses_ACCD_wait,
+ llvm::acc::allowedExclusiveClauses_ACCD_wait,
+ llvm::acc::requiredClauses_ACCD_wait,
+ }
+ },
+}
+
+#endif // GEN_FLANG_DIRECTIVE_CLAUSE_MAP
+
+#ifdef GEN_FLANG_CLAUSE_PARSER_CLASSES
+#undef GEN_FLANG_CLAUSE_PARSER_CLASSES
+
+WRAPPER_CLASS(Async, std::optional<ScalarIntExpr>);
+WRAPPER_CLASS(Attach, AccObjectList);
+EMPTY_CLASS(Auto);
+WRAPPER_CLASS(Bind, AccBindClause);
+EMPTY_CLASS(Capture);
+WRAPPER_CLASS(Collapse, ScalarIntConstantExpr);
+WRAPPER_CLASS(Copy, AccObjectList);
+WRAPPER_CLASS(Copyin, AccObjectListWithModifier);
+WRAPPER_CLASS(Copyout, AccObjectListWithModifier);
+WRAPPER_CLASS(Create, AccObjectListWithModifier);
+WRAPPER_CLASS(Default, AccDefaultClause);
+WRAPPER_CLASS(DefaultAsync, ScalarIntExpr);
+WRAPPER_CLASS(Delete, AccObjectList);
+WRAPPER_CLASS(Detach, AccObjectList);
+WRAPPER_CLASS(Device, AccObjectList);
+WRAPPER_CLASS(DeviceNum, ScalarIntExpr);
+WRAPPER_CLASS(Deviceptr, AccObjectList);
+WRAPPER_CLASS(DeviceResident, AccObjectList);
+WRAPPER_CLASS(DeviceType, std::optional<std::list<ScalarIntExpr>>);
+EMPTY_CLASS(Finalize);
+WRAPPER_CLASS(Firstprivate, AccObjectList);
+WRAPPER_CLASS(Gang, std::optional<AccGangArgument>);
+WRAPPER_CLASS(Host, AccObjectList);
+WRAPPER_CLASS(If, ScalarLogicalExpr);
+EMPTY_CLASS(IfPresent);
+EMPTY_CLASS(Independent);
+WRAPPER_CLASS(Link, AccObjectList);
+WRAPPER_CLASS(NoCreate, AccObjectList);
+EMPTY_CLASS(Nohost);
+WRAPPER_CLASS(NumGangs, ScalarIntExpr);
+WRAPPER_CLASS(NumWorkers, ScalarIntExpr);
+WRAPPER_CLASS(Present, AccObjectList);
+WRAPPER_CLASS(Private, AccObjectList);
+EMPTY_CLASS(Read);
+WRAPPER_CLASS(Reduction, AccObjectListWithReduction);
+WRAPPER_CLASS(Self, AccSelfClause);
+EMPTY_CLASS(Seq);
+WRAPPER_CLASS(Tile, AccTileExprList);
+EMPTY_CLASS(Unknown);
+WRAPPER_CLASS(UseDevice, AccObjectList);
+WRAPPER_CLASS(Vector, std::optional<ScalarIntExpr>);
+WRAPPER_CLASS(VectorLength, ScalarIntExpr);
+WRAPPER_CLASS(Wait, std::optional<AccWaitArgument>);
+WRAPPER_CLASS(Worker, std::optional<ScalarIntExpr>);
+EMPTY_CLASS(Write);
+
+#endif // GEN_FLANG_CLAUSE_PARSER_CLASSES
+
+#ifdef GEN_FLANG_CLAUSE_PARSER_CLASSES_LIST
+#undef GEN_FLANG_CLAUSE_PARSER_CLASSES_LIST
+
+Async
+, Attach
+, Auto
+, Bind
+, Capture
+, Collapse
+, Copy
+, Copyin
+, Copyout
+, Create
+, Default
+, DefaultAsync
+, Delete
+, Detach
+, Device
+, DeviceNum
+, Deviceptr
+, DeviceResident
+, DeviceType
+, Finalize
+, Firstprivate
+, Gang
+, Host
+, If
+, IfPresent
+, Independent
+, Link
+, NoCreate
+, Nohost
+, NumGangs
+, NumWorkers
+, Present
+, Private
+, Read
+, Reduction
+, Self
+, Seq
+, Tile
+, Unknown
+, UseDevice
+, Vector
+, VectorLength
+, Wait
+, Worker
+, Write
+
+#endif // GEN_FLANG_CLAUSE_PARSER_CLASSES_LIST
+
+#ifdef GEN_FLANG_DUMP_PARSE_TREE_CLAUSES
+#undef GEN_FLANG_DUMP_PARSE_TREE_CLAUSES
+
+NODE(AccClause, Async)
+NODE(AccClause, Attach)
+NODE(AccClause, Auto)
+NODE(AccClause, Bind)
+NODE(AccClause, Capture)
+NODE(AccClause, Collapse)
+NODE(AccClause, Copy)
+NODE(AccClause, Copyin)
+NODE(AccClause, Copyout)
+NODE(AccClause, Create)
+NODE(AccClause, Default)
+NODE(AccClause, DefaultAsync)
+NODE(AccClause, Delete)
+NODE(AccClause, Detach)
+NODE(AccClause, Device)
+NODE(AccClause, DeviceNum)
+NODE(AccClause, Deviceptr)
+NODE(AccClause, DeviceResident)
+NODE(AccClause, DeviceType)
+NODE(AccClause, Finalize)
+NODE(AccClause, Firstprivate)
+NODE(AccClause, Gang)
+NODE(AccClause, Host)
+NODE(AccClause, If)
+NODE(AccClause, IfPresent)
+NODE(AccClause, Independent)
+NODE(AccClause, Link)
+NODE(AccClause, NoCreate)
+NODE(AccClause, Nohost)
+NODE(AccClause, NumGangs)
+NODE(AccClause, NumWorkers)
+NODE(AccClause, Present)
+NODE(AccClause, Private)
+NODE(AccClause, Read)
+NODE(AccClause, Reduction)
+NODE(AccClause, Self)
+NODE(AccClause, Seq)
+NODE(AccClause, Tile)
+NODE(AccClause, Unknown)
+NODE(AccClause, UseDevice)
+NODE(AccClause, Vector)
+NODE(AccClause, VectorLength)
+NODE(AccClause, Wait)
+NODE(AccClause, Worker)
+NODE(AccClause, Write)
+
+#endif // GEN_FLANG_DUMP_PARSE_TREE_CLAUSES
+
+#ifdef GEN_FLANG_CLAUSE_UNPARSE
+#undef GEN_FLANG_CLAUSE_UNPARSE
+
+void Unparse(const AccClause::Async &x) {
+ Word("ASYNC");
+ Walk("(", x.v, ")");
+}
+void Unparse(const AccClause::Attach &x) {
+ Word("ATTACH");
+ Put("(");
+ Walk(x.v);
+ Put(")");
+}
+void Before(const AccClause::Auto &) { Word("AUTO"); }
+void Unparse(const AccClause::Bind &x) {
+ Word("BIND");
+ Put("(");
+ Walk(x.v);
+ Put(")");
+}
+void Before(const AccClause::Capture &) { Word("CAPTURE"); }
+void Unparse(const AccClause::Collapse &x) {
+ Word("COLLAPSE");
+ Put("(");
+ Walk(x.v);
+ Put(")");
+}
+void Unparse(const AccClause::Copy &x) {
+ Word("COPY");
+ Put("(");
+ Walk(x.v);
+ Put(")");
+}
+void Unparse(const AccClause::Copyin &x) {
+ Word("COPYIN");
+ Put("(");
+ Walk(x.v);
+ Put(")");
+}
+void Unparse(const AccClause::Copyout &x) {
+ Word("COPYOUT");
+ Put("(");
+ Walk(x.v);
+ Put(")");
+}
+void Unparse(const AccClause::Create &x) {
+ Word("CREATE");
+ Put("(");
+ Walk(x.v);
+ Put(")");
+}
+void Unparse(const AccClause::Default &x) {
+ Word("DEFAULT");
+ Put("(");
+ Walk(x.v);
+ Put(")");
+}
+void Unparse(const AccClause::DefaultAsync &x) {
+ Word("DEFAULT_ASYNC");
+ Put("(");
+ Walk(x.v);
+ Put(")");
+}
+void Unparse(const AccClause::Delete &x) {
+ Word("DELETE");
+ Put("(");
+ Walk(x.v);
+ Put(")");
+}
+void Unparse(const AccClause::Detach &x) {
+ Word("DETACH");
+ Put("(");
+ Walk(x.v);
+ Put(")");
+}
+void Unparse(const AccClause::Device &x) {
+ Word("DEVICE");
+ Put("(");
+ Walk(x.v);
+ Put(")");
+}
+void Unparse(const AccClause::DeviceNum &x) {
+ Word("DEVICE_NUM");
+ Put("(");
+ Walk(x.v);
+ Put(")");
+}
+void Unparse(const AccClause::Deviceptr &x) {
+ Word("DEVICEPTR");
+ Put("(");
+ Walk(x.v);
+ Put(")");
+}
+void Unparse(const AccClause::DeviceResident &x) {
+ Word("DEVICE_RESIDENT");
+ Put("(");
+ Walk(x.v);
+ Put(")");
+}
+void Unparse(const AccClause::DeviceType &x) {
+ Word("DEVICE_TYPE");
+ Put("(");
+ if (x.v.has_value())
+ Walk(x.v, ",");
+ else
+ Put("*");
+ Put(")");
+}
+void Before(const AccClause::Finalize &) { Word("FINALIZE"); }
+void Unparse(const AccClause::Firstprivate &x) {
+ Word("FIRSTPRIVATE");
+ Put("(");
+ Walk(x.v);
+ Put(")");
+}
+void Unparse(const AccClause::Gang &x) {
+ Word("GANG");
+ Walk("(", x.v, ")");
+}
+void Unparse(const AccClause::Host &x) {
+ Word("HOST");
+ Put("(");
+ Walk(x.v);
+ Put(")");
+}
+void Unparse(const AccClause::If &x) {
+ Word("IF");
+ Put("(");
+ Walk(x.v);
+ Put(")");
+}
+void Before(const AccClause::IfPresent &) { Word("IF_PRESENT"); }
+void Before(const AccClause::Independent &) { Word("INDEPENDENT"); }
+void Unparse(const AccClause::Link &x) {
+ Word("LINK");
+ Put("(");
+ Walk(x.v);
+ Put(")");
+}
+void Unparse(const AccClause::NoCreate &x) {
+ Word("NO_CREATE");
+ Put("(");
+ Walk(x.v);
+ Put(")");
+}
+void Before(const AccClause::Nohost &) { Word("NOHOST"); }
+void Unparse(const AccClause::NumGangs &x) {
+ Word("NUM_GANGS");
+ Put("(");
+ Walk(x.v);
+ Put(")");
+}
+void Unparse(const AccClause::NumWorkers &x) {
+ Word("NUM_WORKERS");
+ Put("(");
+ Walk(x.v);
+ Put(")");
+}
+void Unparse(const AccClause::Present &x) {
+ Word("PRESENT");
+ Put("(");
+ Walk(x.v);
+ Put(")");
+}
+void Unparse(const AccClause::Private &x) {
+ Word("PRIVATE");
+ Put("(");
+ Walk(x.v);
+ Put(")");
+}
+void Before(const AccClause::Read &) { Word("READ"); }
+void Unparse(const AccClause::Reduction &x) {
+ Word("REDUCTION");
+ Put("(");
+ Walk(x.v);
+ Put(")");
+}
+void Unparse(const AccClause::Self &x) {
+ Word("SELF");
+ Put("(");
+ Walk(x.v);
+ Put(")");
+}
+void Before(const AccClause::Seq &) { Word("SEQ"); }
+void Unparse(const AccClause::Tile &x) {
+ Word("TILE");
+ Put("(");
+ Walk(x.v);
+ Put(")");
+}
+void Before(const AccClause::Unknown &) { Word("UNKNOWN"); }
+void Unparse(const AccClause::UseDevice &x) {
+ Word("USE_DEVICE");
+ Put("(");
+ Walk(x.v);
+ Put(")");
+}
+void Unparse(const AccClause::Vector &x) {
+ Word("VECTOR");
+ Walk("(", x.v, ")");
+}
+void Unparse(const AccClause::VectorLength &x) {
+ Word("VECTOR_LENGTH");
+ Put("(");
+ Walk(x.v);
+ Put(")");
+}
+void Unparse(const AccClause::Wait &x) {
+ Word("WAIT");
+ Walk("(", x.v, ")");
+}
+void Unparse(const AccClause::Worker &x) {
+ Word("WORKER");
+ Walk("(", x.v, ")");
+}
+void Before(const AccClause::Write &) { Word("WRITE"); }
+
+#endif // GEN_FLANG_CLAUSE_UNPARSE
+
+#ifdef GEN_CLANG_CLAUSE_CLASS
+#undef GEN_CLANG_CLAUSE_CLASS
+
+#ifndef CLAUSE
+#define CLAUSE(Enum, Str, Implicit)
+#endif
+#ifndef CLAUSE_CLASS
+#define CLAUSE_CLASS(Enum, Str, Class)
+#endif
+#ifndef CLAUSE_NO_CLASS
+#define CLAUSE_NO_CLASS(Enum, Str)
+#endif
+
+#define __CLAUSE(Name, Class) \
+ CLAUSE(ACCC_##Name, #Name, /* Implicit */ false) \
+ CLAUSE_CLASS(ACCC_##Name, #Name, Class)
+#define __CLAUSE_NO_CLASS(Name) \
+ CLAUSE(ACCC_##Name, #Name, /* Implicit */ false) \
+ CLAUSE_NO_CLASS(ACCC_##Name, #Name)
+#define __IMPLICIT_CLAUSE_CLASS(Name, Str, Class) \
+ CLAUSE(ACCC_##Name, Str, /* Implicit */ true) \
+ CLAUSE_CLASS(ACCC_##Name, Str, Class)
+#define __IMPLICIT_CLAUSE_NO_CLASS(Name, Str) \
+ CLAUSE(ACCC_##Name, Str, /* Implicit */ true) \
+ CLAUSE_NO_CLASS(ACCC_##Name, Str)
+
+__CLAUSE_NO_CLASS(async)
+__CLAUSE_NO_CLASS(attach)
+__CLAUSE_NO_CLASS(auto)
+__CLAUSE_NO_CLASS(bind)
+__CLAUSE_NO_CLASS(capture)
+__CLAUSE_NO_CLASS(collapse)
+__CLAUSE_NO_CLASS(copy)
+__CLAUSE_NO_CLASS(copyin)
+__CLAUSE_NO_CLASS(copyout)
+__CLAUSE_NO_CLASS(create)
+__CLAUSE_NO_CLASS(default)
+__CLAUSE_NO_CLASS(default_async)
+__CLAUSE_NO_CLASS(delete)
+__CLAUSE_NO_CLASS(detach)
+__CLAUSE_NO_CLASS(device)
+__CLAUSE_NO_CLASS(device_num)
+__CLAUSE_NO_CLASS(deviceptr)
+__CLAUSE_NO_CLASS(device_resident)
+__CLAUSE_NO_CLASS(device_type)
+__CLAUSE_NO_CLASS(finalize)
+__CLAUSE_NO_CLASS(firstprivate)
+__CLAUSE_NO_CLASS(gang)
+__CLAUSE_NO_CLASS(host)
+__CLAUSE_NO_CLASS(if)
+__CLAUSE_NO_CLASS(if_present)
+__CLAUSE_NO_CLASS(independent)
+__CLAUSE_NO_CLASS(link)
+__CLAUSE_NO_CLASS(no_create)
+__CLAUSE_NO_CLASS(nohost)
+__CLAUSE_NO_CLASS(num_gangs)
+__CLAUSE_NO_CLASS(num_workers)
+__CLAUSE_NO_CLASS(present)
+__CLAUSE_NO_CLASS(private)
+__CLAUSE_NO_CLASS(read)
+__CLAUSE_NO_CLASS(reduction)
+__CLAUSE_NO_CLASS(self)
+__CLAUSE_NO_CLASS(seq)
+__CLAUSE_NO_CLASS(tile)
+__CLAUSE_NO_CLASS(unknown)
+__CLAUSE_NO_CLASS(use_device)
+__CLAUSE_NO_CLASS(vector)
+__CLAUSE_NO_CLASS(vector_length)
+__CLAUSE_NO_CLASS(wait)
+__CLAUSE_NO_CLASS(worker)
+__CLAUSE_NO_CLASS(write)
+
+#undef __IMPLICIT_CLAUSE_NO_CLASS
+#undef __IMPLICIT_CLAUSE_CLASS
+#undef __CLAUSE
+#undef CLAUSE_NO_CLASS
+#undef CLAUSE_CLASS
+#undef CLAUSE
+
+#endif // GEN_CLANG_CLAUSE_CLASS
+
diff --git a/linux-x64/clang/include/llvm/Frontend/OpenACC/ACC.td b/linux-x64/clang/include/llvm/Frontend/OpenACC/ACC.td
new file mode 100644
index 0000000..58bb73f
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Frontend/OpenACC/ACC.td
@@ -0,0 +1,630 @@
+//===-- ACC.td - OpenACC directive definition file ---------*- tablegen -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This is the definition file for OpenACC 3.1 directives and clauses.
+//
+//===----------------------------------------------------------------------===//
+
+include "llvm/Frontend/Directive/DirectiveBase.td"
+
+//===----------------------------------------------------------------------===//
+// Definition of general OpenACC information
+//===----------------------------------------------------------------------===//
+
+def OpenACC : DirectiveLanguage {
+ let name = "OpenACC";
+ let cppNamespace = "acc"; // final namespace will be llvm::acc
+ let directivePrefix = "ACCD_";
+ let clausePrefix = "ACCC_";
+ let makeEnumAvailableInNamespace = true;
+ let enableBitmaskEnumInNamespace = true;
+ let includeHeader = "llvm/Frontend/OpenACC/ACC.h.inc";
+ let clauseEnumSetClass = "AccClauseSet";
+ let flangClauseBaseClass = "AccClause";
+}
+
+//===----------------------------------------------------------------------===//
+// Definition of OpenACC clauses
+//===----------------------------------------------------------------------===//
+
+// 2.16.1
+def ACCC_Async : Clause<"async"> {
+ let flangClassValue = "ScalarIntExpr";
+ let isValueOptional = true;
+}
+
+// 2.9.7
+def ACCC_Auto : Clause<"auto"> {}
+
+// 2.7.12
+def ACCC_Attach : Clause<"attach"> {
+ let flangClassValue = "AccObjectList";
+}
+
+// 2.15.1
+def ACCC_Bind : Clause<"bind"> {
+ let flangClassValue = "AccBindClause";
+}
+
+// 2.12
+def ACCC_Capture : Clause<"capture"> {
+}
+
+// 2.9.1
+def ACCC_Collapse : Clause<"collapse"> {
+ let flangClassValue = "ScalarIntConstantExpr";
+}
+
+// 2.7.6
+def ACCC_Copy : Clause<"copy"> {
+ let flangClassValue = "AccObjectList";
+}
+// 2.7.7
+def ACCC_Copyin : Clause<"copyin"> {
+ let flangClassValue = "AccObjectListWithModifier";
+}
+
+// 2.7.8
+def ACCC_Copyout : Clause<"copyout"> {
+ let flangClassValue = "AccObjectListWithModifier";
+}
+
+// 2.7.9
+def ACCC_Create : Clause<"create"> {
+ let flangClassValue = "AccObjectListWithModifier";
+}
+
+// 2.5.15
+def ACC_Default_none : ClauseVal<"none", 1, 1> { let isDefault = 1; }
+def ACC_Default_present : ClauseVal<"present", 0, 1> {}
+
+def ACCC_Default : Clause<"default"> {
+ let flangClassValue = "AccDefaultClause";
+ let enumClauseValue = "DefaultValue";
+ let allowedClauseValues = [
+ ACC_Default_present,
+ ACC_Default_none
+ ];
+}
+
+// 2.14.3
+def ACCC_DefaultAsync : Clause<"default_async"> {
+ let flangClassValue = "ScalarIntExpr";
+}
+
+// 2.7.11
+def ACCC_Delete : Clause<"delete"> {
+ let flangClassValue = "AccObjectList";
+}
+
+// 2.7.13
+def ACCC_Detach : Clause<"detach"> {
+ let flangClassValue = "AccObjectList";
+}
+
+// 2.14.4
+def ACCC_Device : Clause<"device"> {
+ let flangClassValue = "AccObjectList";
+}
+
+// 2.14.1 - 2.14.2
+def ACCC_DeviceNum : Clause<"device_num"> {
+ let flangClassValue = "ScalarIntExpr";
+}
+
+// 2.7.4
+def ACCC_DevicePtr : Clause<"deviceptr"> {
+ let flangClassValue = "AccObjectList";
+}
+
+// 2.13.1
+def ACCC_DeviceResident : Clause<"device_resident"> {
+ let flangClassValue = "AccObjectList";
+}
+
+// 2.4
+def ACCC_DeviceType : Clause<"device_type"> {
+ let flangClassValue = "ScalarIntExpr";
+ let defaultValue = "*";
+ let isValueOptional = true;
+ let isValueList = true;
+}
+
+// 2.6.6
+def ACCC_Finalize : Clause<"finalize"> {}
+
+// 2.5.13
+def ACCC_FirstPrivate : Clause<"firstprivate"> {
+ let flangClassValue = "AccObjectList";
+}
+
+// 2.9.2
+def ACCC_Gang : Clause<"gang"> {
+ let flangClassValue = "AccGangArgument";
+ let isValueOptional = true;
+}
+
+// 2.14.4
+def ACCC_Host : Clause<"host"> {
+ let flangClassValue = "AccObjectList";
+}
+
+// 2.5.5
+def ACCC_If : Clause <"if"> {
+ let flangClassValue = "ScalarLogicalExpr";
+}
+
+// 2.14.4
+def ACCC_IfPresent : Clause<"if_present"> {}
+
+// 2.9.6
+def ACCC_Independent : Clause<"independent"> {}
+
+// 2.13.3
+def ACCC_Link : Clause<"link"> {
+ let flangClassValue = "AccObjectList";
+}
+
+// 2.7.10
+def ACCC_NoCreate : Clause<"no_create"> {
+ let flangClassValue = "AccObjectList";
+}
+
+// 2.15.1
+def ACCC_NoHost : Clause<"nohost"> {}
+
+// 2.5.9
+def ACCC_NumGangs : Clause<"num_gangs"> {
+ let flangClassValue = "ScalarIntExpr";
+}
+
+// 2.5.10
+def ACCC_NumWorkers : Clause<"num_workers"> {
+ let flangClassValue = "ScalarIntExpr";
+}
+
+// 2.7.5
+def ACCC_Present : Clause<"present"> {
+ let flangClassValue = "AccObjectList";
+}
+
+// 2.5.12
+def ACCC_Private : Clause<"private"> {
+ let flangClassValue = "AccObjectList";
+}
+
+// 2.9.8
+def ACCC_Tile : Clause <"tile"> {
+ let flangClassValue = "AccTileExprList";
+}
+
+// 2.8.1
+def ACCC_UseDevice : Clause <"use_device"> {
+ let flangClassValue = "AccObjectList";
+}
+
+// 2.12
+def ACCC_Read : Clause<"read"> {}
+
+// 2.5.14
+def ACCC_Reduction : Clause<"reduction"> {
+ let flangClassValue = "AccObjectListWithReduction";
+}
+
+// 2.5.6
+def ACCC_Self : Clause<"self"> {
+ let flangClassValue = "AccSelfClause";
+}
+
+// 2.9.5
+def ACCC_Seq : Clause<"seq"> {}
+
+// 2.9.4
+def ACCC_Vector : Clause<"vector"> {
+ let flangClassValue = "ScalarIntExpr";
+ let isValueOptional = true;
+}
+
+// 2.5.11
+def ACCC_VectorLength : Clause<"vector_length"> {
+ let flangClassValue = "ScalarIntExpr";
+}
+
+// 2.16.2
+def ACCC_Wait : Clause<"wait"> {
+ let flangClassValue = "AccWaitArgument";
+ let isValueOptional = true;
+}
+
+// 2.9.3
+def ACCC_Worker: Clause<"worker"> {
+ let flangClassValue = "ScalarIntExpr";
+ let isValueOptional = true;
+}
+
+// 2.12
+def ACCC_Write : Clause<"write"> {}
+
+def ACCC_Unknown : Clause<"unknown"> {
+ let isDefault = true;
+}
+
+//===----------------------------------------------------------------------===//
+// Definition of OpenACC directives
+//===----------------------------------------------------------------------===//
+
+// 2.12
+def ACC_Atomic : Directive<"atomic"> {}
+
+// 2.6.5
+def ACC_Data : Directive<"data"> {
+ let allowedOnceClauses = [
+ VersionedClause<ACCC_If>,
+ VersionedClause<ACCC_Default>
+ ];
+ let requiredClauses = [
+ VersionedClause<ACCC_Attach>,
+ VersionedClause<ACCC_Copy>,
+ VersionedClause<ACCC_Copyin>,
+ VersionedClause<ACCC_Copyout>,
+ VersionedClause<ACCC_Create>,
+ VersionedClause<ACCC_Default>,
+ VersionedClause<ACCC_DevicePtr>,
+ VersionedClause<ACCC_NoCreate>,
+ VersionedClause<ACCC_Present>
+ ];
+}
+
+// 2.13
+def ACC_Declare : Directive<"declare"> {
+ let allowedClauses = [
+ VersionedClause<ACCC_Copy>,
+ VersionedClause<ACCC_Copyin>,
+ VersionedClause<ACCC_Copyout>,
+ VersionedClause<ACCC_Create>,
+ VersionedClause<ACCC_Present>,
+ VersionedClause<ACCC_DevicePtr>,
+ VersionedClause<ACCC_DeviceResident>,
+ VersionedClause<ACCC_Link>
+ ];
+}
+
+// 2.5.3
+def ACC_Kernels : Directive<"kernels"> {
+ let allowedClauses = [
+ VersionedClause<ACCC_Attach>,
+ VersionedClause<ACCC_Copy>,
+ VersionedClause<ACCC_Copyin>,
+ VersionedClause<ACCC_Copyout>,
+ VersionedClause<ACCC_Create>,
+ VersionedClause<ACCC_DeviceType>,
+ VersionedClause<ACCC_NoCreate>,
+ VersionedClause<ACCC_Present>,
+ VersionedClause<ACCC_DevicePtr>,
+ VersionedClause<ACCC_Wait>
+ ];
+ let allowedOnceClauses = [
+ VersionedClause<ACCC_Async>,
+ VersionedClause<ACCC_Default>,
+ VersionedClause<ACCC_If>,
+ VersionedClause<ACCC_NumGangs>,
+ VersionedClause<ACCC_NumWorkers>,
+ VersionedClause<ACCC_Self>,
+ VersionedClause<ACCC_VectorLength>
+ ];
+}
+
+// 2.5.1
+def ACC_Parallel : Directive<"parallel"> {
+ let allowedClauses = [
+ VersionedClause<ACCC_Attach>,
+ VersionedClause<ACCC_Copy>,
+ VersionedClause<ACCC_Copyin>,
+ VersionedClause<ACCC_Copyout>,
+ VersionedClause<ACCC_Create>,
+ VersionedClause<ACCC_DevicePtr>,
+ VersionedClause<ACCC_DeviceType>,
+ VersionedClause<ACCC_NoCreate>,
+ VersionedClause<ACCC_Present>,
+ VersionedClause<ACCC_Private>,
+ VersionedClause<ACCC_FirstPrivate>,
+ VersionedClause<ACCC_Wait>
+ ];
+ let allowedOnceClauses = [
+ VersionedClause<ACCC_Async>,
+ VersionedClause<ACCC_Default>,
+ VersionedClause<ACCC_If>,
+ VersionedClause<ACCC_NumGangs>,
+ VersionedClause<ACCC_NumWorkers>,
+ VersionedClause<ACCC_Reduction>,
+ VersionedClause<ACCC_Self>,
+ VersionedClause<ACCC_VectorLength>
+ ];
+}
+
+// 2.5.2
+def ACC_Serial : Directive<"serial"> {
+ // Spec line 950-951: clause is as for the parallel construct except that the
+ // num_gangs, num_workers, and vector_length clauses are not permitted.
+ let allowedClauses = [
+ VersionedClause<ACCC_Attach>,
+ VersionedClause<ACCC_Copy>,
+ VersionedClause<ACCC_Copyin>,
+ VersionedClause<ACCC_Copyout>,
+ VersionedClause<ACCC_Create>,
+ VersionedClause<ACCC_DevicePtr>,
+ VersionedClause<ACCC_DeviceType>,
+ VersionedClause<ACCC_NoCreate>,
+ VersionedClause<ACCC_Present>,
+ VersionedClause<ACCC_Private>,
+ VersionedClause<ACCC_FirstPrivate>,
+ VersionedClause<ACCC_Wait>
+ ];
+ let allowedOnceClauses = [
+ VersionedClause<ACCC_Async>,
+ VersionedClause<ACCC_Default>,
+ VersionedClause<ACCC_If>,
+ VersionedClause<ACCC_Reduction>,
+ VersionedClause<ACCC_Self>
+ ];
+}
+
+// 2.9
+def ACC_Loop : Directive<"loop"> {
+ let allowedClauses = [
+ VersionedClause<ACCC_DeviceType>,
+ VersionedClause<ACCC_Private>
+ ];
+ let allowedOnceClauses = [
+ VersionedClause<ACCC_Collapse>,
+ VersionedClause<ACCC_Gang>,
+ VersionedClause<ACCC_Reduction>,
+ VersionedClause<ACCC_Tile>,
+ VersionedClause<ACCC_Vector>,
+ VersionedClause<ACCC_Worker>
+ ];
+ let allowedExclusiveClauses = [
+ VersionedClause<ACCC_Auto>,
+ VersionedClause<ACCC_Independent>,
+ VersionedClause<ACCC_Seq>
+ ];
+}
+
+// 2.10
+def ACC_Cache : Directive<"cache"> {}
+
+// 2.14.1
+def ACC_Init : Directive<"init"> {
+ let allowedOnceClauses = [
+ VersionedClause<ACCC_DeviceNum>,
+ VersionedClause<ACCC_DeviceType>,
+ VersionedClause<ACCC_If>
+ ];
+}
+
+// 2.15.1
+def ACC_Routine : Directive<"routine"> {
+ let allowedOnceClauses = [
+ VersionedClause<ACCC_Bind>,
+ VersionedClause<ACCC_DeviceType>,
+ VersionedClause<ACCC_NoHost>
+ ];
+ let requiredClauses = [
+ VersionedClause<ACCC_Gang>,
+ VersionedClause<ACCC_Seq>,
+ VersionedClause<ACCC_Vector>,
+ VersionedClause<ACCC_Worker>
+ ];
+}
+
+// 2.14.3
+def ACC_Set : Directive<"set"> {
+ let allowedOnceClauses = [
+ VersionedClause<ACCC_DefaultAsync>,
+ VersionedClause<ACCC_DeviceNum>,
+ VersionedClause<ACCC_DeviceType>,
+ VersionedClause<ACCC_If>
+ ];
+ let requiredClauses = [
+ // The three following clauses are also in allowedOnceClauses list due to
+ // restriction 2255 - Two instances of the same clause may not appear on the
+ // same directive.
+ VersionedClause<ACCC_DefaultAsync>,
+ VersionedClause<ACCC_DeviceNum>,
+ VersionedClause<ACCC_DeviceType>
+ ];
+}
+
+// 2.14.2
+def ACC_Shutdown : Directive<"shutdown"> {
+ let allowedOnceClauses = [
+ VersionedClause<ACCC_DeviceNum>,
+ VersionedClause<ACCC_DeviceType>,
+ VersionedClause<ACCC_If>
+ ];
+}
+
+// 2.14.4
+def ACC_Update : Directive<"update"> {
+ let allowedClauses = [
+ VersionedClause<ACCC_DeviceType>,
+ VersionedClause<ACCC_Wait>
+ ];
+ let allowedOnceClauses = [
+ VersionedClause<ACCC_Async>,
+ VersionedClause<ACCC_If>,
+ VersionedClause<ACCC_IfPresent>
+ ];
+ let requiredClauses = [
+ VersionedClause<ACCC_Device>,
+ VersionedClause<ACCC_Host>,
+ VersionedClause<ACCC_Self>
+ ];
+}
+
+// 2.16.3
+def ACC_Wait : Directive<"wait"> {
+ let allowedOnceClauses = [
+ VersionedClause<ACCC_Async>,
+ VersionedClause<ACCC_If>
+ ];
+}
+
+// 2.14.6
+def ACC_EnterData : Directive<"enter data"> {
+ let allowedOnceClauses = [
+ VersionedClause<ACCC_Async>,
+ VersionedClause<ACCC_If>,
+ VersionedClause<ACCC_Wait>
+ ];
+ let requiredClauses = [
+ VersionedClause<ACCC_Attach>,
+ VersionedClause<ACCC_Create>,
+ VersionedClause<ACCC_Copyin>
+ ];
+}
+
+// 2.14.7
+def ACC_ExitData : Directive<"exit data"> {
+ let allowedClauses = [
+ VersionedClause<ACCC_Async>,
+ VersionedClause<ACCC_If>,
+ VersionedClause<ACCC_Wait>,
+ VersionedClause<ACCC_Finalize>
+ ];
+ let requiredClauses = [
+ VersionedClause<ACCC_Copyout>,
+ VersionedClause<ACCC_Delete>,
+ VersionedClause<ACCC_Detach>
+ ];
+}
+
+// 2.8
+def ACC_HostData : Directive<"host_data"> {
+ let allowedClauses = [
+ VersionedClause<ACCC_If>,
+ VersionedClause<ACCC_IfPresent>
+ ];
+ let requiredClauses = [
+ VersionedClause<ACCC_UseDevice>
+ ];
+}
+
+// 2.11
+def ACC_KernelsLoop : Directive<"kernels loop"> {
+ let allowedClauses = [
+ VersionedClause<ACCC_Copy>,
+ VersionedClause<ACCC_Copyin>,
+ VersionedClause<ACCC_Copyout>,
+ VersionedClause<ACCC_Create>,
+ VersionedClause<ACCC_DeviceType>,
+ VersionedClause<ACCC_NoCreate>,
+ VersionedClause<ACCC_Present>,
+ VersionedClause<ACCC_Private>,
+ VersionedClause<ACCC_DevicePtr>,
+ VersionedClause<ACCC_Attach>
+ ];
+ let allowedOnceClauses = [
+ VersionedClause<ACCC_Async>,
+ VersionedClause<ACCC_Collapse>,
+ VersionedClause<ACCC_Default>,
+ VersionedClause<ACCC_Gang>,
+ VersionedClause<ACCC_If>,
+ VersionedClause<ACCC_NumGangs>,
+ VersionedClause<ACCC_NumWorkers>,
+ VersionedClause<ACCC_Reduction>,
+ VersionedClause<ACCC_Self>,
+ VersionedClause<ACCC_Tile>,
+ VersionedClause<ACCC_Vector>,
+ VersionedClause<ACCC_VectorLength>,
+ VersionedClause<ACCC_Wait>,
+ VersionedClause<ACCC_Worker>
+ ];
+ let allowedExclusiveClauses = [
+ VersionedClause<ACCC_Auto>,
+ VersionedClause<ACCC_Independent>,
+ VersionedClause<ACCC_Seq>
+ ];
+}
+
+// 2.11
+def ACC_ParallelLoop : Directive<"parallel loop"> {
+ let allowedClauses = [
+ VersionedClause<ACCC_Attach>,
+ VersionedClause<ACCC_Copy>,
+ VersionedClause<ACCC_Copyin>,
+ VersionedClause<ACCC_Copyout>,
+ VersionedClause<ACCC_Create>,
+ VersionedClause<ACCC_DevicePtr>,
+ VersionedClause<ACCC_DeviceType>,
+ VersionedClause<ACCC_FirstPrivate>,
+ VersionedClause<ACCC_NoCreate>,
+ VersionedClause<ACCC_Present>,
+ VersionedClause<ACCC_Private>,
+ VersionedClause<ACCC_Tile>,
+ VersionedClause<ACCC_Wait>
+ ];
+ let allowedOnceClauses = [
+ VersionedClause<ACCC_Async>,
+ VersionedClause<ACCC_Collapse>,
+ VersionedClause<ACCC_Default>,
+ VersionedClause<ACCC_Gang>,
+ VersionedClause<ACCC_If>,
+ VersionedClause<ACCC_NumGangs>,
+ VersionedClause<ACCC_NumWorkers>,
+ VersionedClause<ACCC_Reduction>,
+ VersionedClause<ACCC_Self>,
+ VersionedClause<ACCC_Vector>,
+ VersionedClause<ACCC_VectorLength>,
+ VersionedClause<ACCC_Worker>
+ ];
+ let allowedExclusiveClauses = [
+ VersionedClause<ACCC_Auto>,
+ VersionedClause<ACCC_Independent>,
+ VersionedClause<ACCC_Seq>
+ ];
+}
+
+// 2.11
+def ACC_SerialLoop : Directive<"serial loop"> {
+ let allowedClauses = [
+ VersionedClause<ACCC_Attach>,
+ VersionedClause<ACCC_Copy>,
+ VersionedClause<ACCC_Copyin>,
+ VersionedClause<ACCC_Copyout>,
+ VersionedClause<ACCC_Create>,
+ VersionedClause<ACCC_DevicePtr>,
+ VersionedClause<ACCC_DeviceType>,
+ VersionedClause<ACCC_FirstPrivate>,
+ VersionedClause<ACCC_NoCreate>,
+ VersionedClause<ACCC_Present>,
+ VersionedClause<ACCC_Private>,
+ VersionedClause<ACCC_Wait>
+ ];
+ let allowedOnceClauses = [
+ VersionedClause<ACCC_Async>,
+ VersionedClause<ACCC_Collapse>,
+ VersionedClause<ACCC_Default>,
+ VersionedClause<ACCC_Gang>,
+ VersionedClause<ACCC_If>,
+ VersionedClause<ACCC_Reduction>,
+ VersionedClause<ACCC_Self>,
+ VersionedClause<ACCC_Tile>,
+ VersionedClause<ACCC_Vector>,
+ VersionedClause<ACCC_Worker>
+ ];
+ let allowedExclusiveClauses = [
+ VersionedClause<ACCC_Auto>,
+ VersionedClause<ACCC_Independent>,
+ VersionedClause<ACCC_Seq>
+ ];
+}
+
+def ACC_Unknown : Directive<"unknown"> {
+ let isDefault = true;
+}
diff --git a/linux-x64/clang/include/llvm/Frontend/OpenMP/OMP.h.inc b/linux-x64/clang/include/llvm/Frontend/OpenMP/OMP.h.inc
new file mode 100644
index 0000000..aec25f7
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Frontend/OpenMP/OMP.h.inc
@@ -0,0 +1,411 @@
+#ifndef LLVM_OpenMP_INC
+#define LLVM_OpenMP_INC
+
+#include "llvm/ADT/BitmaskEnum.h"
+
+namespace llvm {
+class StringRef;
+namespace omp {
+
+LLVM_ENABLE_BITMASK_ENUMS_IN_NAMESPACE();
+
+enum class Directive {
+ OMPD_allocate,
+ OMPD_assumes,
+ OMPD_atomic,
+ OMPD_barrier,
+ OMPD_begin_assumes,
+ OMPD_begin_declare_variant,
+ OMPD_cancel,
+ OMPD_cancellation_point,
+ OMPD_critical,
+ OMPD_declare_mapper,
+ OMPD_declare_reduction,
+ OMPD_declare_simd,
+ OMPD_declare_target,
+ OMPD_declare_variant,
+ OMPD_depobj,
+ OMPD_distribute,
+ OMPD_distribute_parallel_do,
+ OMPD_distribute_parallel_do_simd,
+ OMPD_distribute_parallel_for,
+ OMPD_distribute_parallel_for_simd,
+ OMPD_distribute_simd,
+ OMPD_do,
+ OMPD_do_simd,
+ OMPD_end_assumes,
+ OMPD_end_declare_target,
+ OMPD_end_declare_variant,
+ OMPD_end_do,
+ OMPD_end_do_simd,
+ OMPD_end_sections,
+ OMPD_end_single,
+ OMPD_end_workshare,
+ OMPD_flush,
+ OMPD_for,
+ OMPD_for_simd,
+ OMPD_master,
+ OMPD_master_taskloop,
+ OMPD_master_taskloop_simd,
+ OMPD_ordered,
+ OMPD_parallel,
+ OMPD_parallel_do,
+ OMPD_parallel_do_simd,
+ OMPD_parallel_for,
+ OMPD_parallel_for_simd,
+ OMPD_parallel_master,
+ OMPD_parallel_master_taskloop,
+ OMPD_parallel_master_taskloop_simd,
+ OMPD_parallel_sections,
+ OMPD_parallel_workshare,
+ OMPD_requires,
+ OMPD_scan,
+ OMPD_section,
+ OMPD_sections,
+ OMPD_simd,
+ OMPD_single,
+ OMPD_target,
+ OMPD_target_data,
+ OMPD_target_enter_data,
+ OMPD_target_exit_data,
+ OMPD_target_parallel,
+ OMPD_target_parallel_do,
+ OMPD_target_parallel_do_simd,
+ OMPD_target_parallel_for,
+ OMPD_target_parallel_for_simd,
+ OMPD_target_simd,
+ OMPD_target_teams,
+ OMPD_target_teams_distribute,
+ OMPD_target_teams_distribute_parallel_do,
+ OMPD_target_teams_distribute_parallel_do_simd,
+ OMPD_target_teams_distribute_parallel_for,
+ OMPD_target_teams_distribute_parallel_for_simd,
+ OMPD_target_teams_distribute_simd,
+ OMPD_target_update,
+ OMPD_task,
+ OMPD_taskgroup,
+ OMPD_taskloop,
+ OMPD_taskloop_simd,
+ OMPD_taskwait,
+ OMPD_taskyield,
+ OMPD_teams,
+ OMPD_teams_distribute,
+ OMPD_teams_distribute_parallel_do,
+ OMPD_teams_distribute_parallel_do_simd,
+ OMPD_teams_distribute_parallel_for,
+ OMPD_teams_distribute_parallel_for_simd,
+ OMPD_teams_distribute_simd,
+ OMPD_threadprivate,
+ OMPD_unknown,
+ OMPD_workshare,
+};
+
+static constexpr std::size_t Directive_enumSize = 88;
+
+constexpr auto OMPD_allocate = llvm::omp::Directive::OMPD_allocate;
+constexpr auto OMPD_assumes = llvm::omp::Directive::OMPD_assumes;
+constexpr auto OMPD_atomic = llvm::omp::Directive::OMPD_atomic;
+constexpr auto OMPD_barrier = llvm::omp::Directive::OMPD_barrier;
+constexpr auto OMPD_begin_assumes = llvm::omp::Directive::OMPD_begin_assumes;
+constexpr auto OMPD_begin_declare_variant = llvm::omp::Directive::OMPD_begin_declare_variant;
+constexpr auto OMPD_cancel = llvm::omp::Directive::OMPD_cancel;
+constexpr auto OMPD_cancellation_point = llvm::omp::Directive::OMPD_cancellation_point;
+constexpr auto OMPD_critical = llvm::omp::Directive::OMPD_critical;
+constexpr auto OMPD_declare_mapper = llvm::omp::Directive::OMPD_declare_mapper;
+constexpr auto OMPD_declare_reduction = llvm::omp::Directive::OMPD_declare_reduction;
+constexpr auto OMPD_declare_simd = llvm::omp::Directive::OMPD_declare_simd;
+constexpr auto OMPD_declare_target = llvm::omp::Directive::OMPD_declare_target;
+constexpr auto OMPD_declare_variant = llvm::omp::Directive::OMPD_declare_variant;
+constexpr auto OMPD_depobj = llvm::omp::Directive::OMPD_depobj;
+constexpr auto OMPD_distribute = llvm::omp::Directive::OMPD_distribute;
+constexpr auto OMPD_distribute_parallel_do = llvm::omp::Directive::OMPD_distribute_parallel_do;
+constexpr auto OMPD_distribute_parallel_do_simd = llvm::omp::Directive::OMPD_distribute_parallel_do_simd;
+constexpr auto OMPD_distribute_parallel_for = llvm::omp::Directive::OMPD_distribute_parallel_for;
+constexpr auto OMPD_distribute_parallel_for_simd = llvm::omp::Directive::OMPD_distribute_parallel_for_simd;
+constexpr auto OMPD_distribute_simd = llvm::omp::Directive::OMPD_distribute_simd;
+constexpr auto OMPD_do = llvm::omp::Directive::OMPD_do;
+constexpr auto OMPD_do_simd = llvm::omp::Directive::OMPD_do_simd;
+constexpr auto OMPD_end_assumes = llvm::omp::Directive::OMPD_end_assumes;
+constexpr auto OMPD_end_declare_target = llvm::omp::Directive::OMPD_end_declare_target;
+constexpr auto OMPD_end_declare_variant = llvm::omp::Directive::OMPD_end_declare_variant;
+constexpr auto OMPD_end_do = llvm::omp::Directive::OMPD_end_do;
+constexpr auto OMPD_end_do_simd = llvm::omp::Directive::OMPD_end_do_simd;
+constexpr auto OMPD_end_sections = llvm::omp::Directive::OMPD_end_sections;
+constexpr auto OMPD_end_single = llvm::omp::Directive::OMPD_end_single;
+constexpr auto OMPD_end_workshare = llvm::omp::Directive::OMPD_end_workshare;
+constexpr auto OMPD_flush = llvm::omp::Directive::OMPD_flush;
+constexpr auto OMPD_for = llvm::omp::Directive::OMPD_for;
+constexpr auto OMPD_for_simd = llvm::omp::Directive::OMPD_for_simd;
+constexpr auto OMPD_master = llvm::omp::Directive::OMPD_master;
+constexpr auto OMPD_master_taskloop = llvm::omp::Directive::OMPD_master_taskloop;
+constexpr auto OMPD_master_taskloop_simd = llvm::omp::Directive::OMPD_master_taskloop_simd;
+constexpr auto OMPD_ordered = llvm::omp::Directive::OMPD_ordered;
+constexpr auto OMPD_parallel = llvm::omp::Directive::OMPD_parallel;
+constexpr auto OMPD_parallel_do = llvm::omp::Directive::OMPD_parallel_do;
+constexpr auto OMPD_parallel_do_simd = llvm::omp::Directive::OMPD_parallel_do_simd;
+constexpr auto OMPD_parallel_for = llvm::omp::Directive::OMPD_parallel_for;
+constexpr auto OMPD_parallel_for_simd = llvm::omp::Directive::OMPD_parallel_for_simd;
+constexpr auto OMPD_parallel_master = llvm::omp::Directive::OMPD_parallel_master;
+constexpr auto OMPD_parallel_master_taskloop = llvm::omp::Directive::OMPD_parallel_master_taskloop;
+constexpr auto OMPD_parallel_master_taskloop_simd = llvm::omp::Directive::OMPD_parallel_master_taskloop_simd;
+constexpr auto OMPD_parallel_sections = llvm::omp::Directive::OMPD_parallel_sections;
+constexpr auto OMPD_parallel_workshare = llvm::omp::Directive::OMPD_parallel_workshare;
+constexpr auto OMPD_requires = llvm::omp::Directive::OMPD_requires;
+constexpr auto OMPD_scan = llvm::omp::Directive::OMPD_scan;
+constexpr auto OMPD_section = llvm::omp::Directive::OMPD_section;
+constexpr auto OMPD_sections = llvm::omp::Directive::OMPD_sections;
+constexpr auto OMPD_simd = llvm::omp::Directive::OMPD_simd;
+constexpr auto OMPD_single = llvm::omp::Directive::OMPD_single;
+constexpr auto OMPD_target = llvm::omp::Directive::OMPD_target;
+constexpr auto OMPD_target_data = llvm::omp::Directive::OMPD_target_data;
+constexpr auto OMPD_target_enter_data = llvm::omp::Directive::OMPD_target_enter_data;
+constexpr auto OMPD_target_exit_data = llvm::omp::Directive::OMPD_target_exit_data;
+constexpr auto OMPD_target_parallel = llvm::omp::Directive::OMPD_target_parallel;
+constexpr auto OMPD_target_parallel_do = llvm::omp::Directive::OMPD_target_parallel_do;
+constexpr auto OMPD_target_parallel_do_simd = llvm::omp::Directive::OMPD_target_parallel_do_simd;
+constexpr auto OMPD_target_parallel_for = llvm::omp::Directive::OMPD_target_parallel_for;
+constexpr auto OMPD_target_parallel_for_simd = llvm::omp::Directive::OMPD_target_parallel_for_simd;
+constexpr auto OMPD_target_simd = llvm::omp::Directive::OMPD_target_simd;
+constexpr auto OMPD_target_teams = llvm::omp::Directive::OMPD_target_teams;
+constexpr auto OMPD_target_teams_distribute = llvm::omp::Directive::OMPD_target_teams_distribute;
+constexpr auto OMPD_target_teams_distribute_parallel_do = llvm::omp::Directive::OMPD_target_teams_distribute_parallel_do;
+constexpr auto OMPD_target_teams_distribute_parallel_do_simd = llvm::omp::Directive::OMPD_target_teams_distribute_parallel_do_simd;
+constexpr auto OMPD_target_teams_distribute_parallel_for = llvm::omp::Directive::OMPD_target_teams_distribute_parallel_for;
+constexpr auto OMPD_target_teams_distribute_parallel_for_simd = llvm::omp::Directive::OMPD_target_teams_distribute_parallel_for_simd;
+constexpr auto OMPD_target_teams_distribute_simd = llvm::omp::Directive::OMPD_target_teams_distribute_simd;
+constexpr auto OMPD_target_update = llvm::omp::Directive::OMPD_target_update;
+constexpr auto OMPD_task = llvm::omp::Directive::OMPD_task;
+constexpr auto OMPD_taskgroup = llvm::omp::Directive::OMPD_taskgroup;
+constexpr auto OMPD_taskloop = llvm::omp::Directive::OMPD_taskloop;
+constexpr auto OMPD_taskloop_simd = llvm::omp::Directive::OMPD_taskloop_simd;
+constexpr auto OMPD_taskwait = llvm::omp::Directive::OMPD_taskwait;
+constexpr auto OMPD_taskyield = llvm::omp::Directive::OMPD_taskyield;
+constexpr auto OMPD_teams = llvm::omp::Directive::OMPD_teams;
+constexpr auto OMPD_teams_distribute = llvm::omp::Directive::OMPD_teams_distribute;
+constexpr auto OMPD_teams_distribute_parallel_do = llvm::omp::Directive::OMPD_teams_distribute_parallel_do;
+constexpr auto OMPD_teams_distribute_parallel_do_simd = llvm::omp::Directive::OMPD_teams_distribute_parallel_do_simd;
+constexpr auto OMPD_teams_distribute_parallel_for = llvm::omp::Directive::OMPD_teams_distribute_parallel_for;
+constexpr auto OMPD_teams_distribute_parallel_for_simd = llvm::omp::Directive::OMPD_teams_distribute_parallel_for_simd;
+constexpr auto OMPD_teams_distribute_simd = llvm::omp::Directive::OMPD_teams_distribute_simd;
+constexpr auto OMPD_threadprivate = llvm::omp::Directive::OMPD_threadprivate;
+constexpr auto OMPD_unknown = llvm::omp::Directive::OMPD_unknown;
+constexpr auto OMPD_workshare = llvm::omp::Directive::OMPD_workshare;
+
+enum class Clause {
+ OMPC_acq_rel,
+ OMPC_acquire,
+ OMPC_affinity,
+ OMPC_aligned,
+ OMPC_allocate,
+ OMPC_allocator,
+ OMPC_atomic_default_mem_order,
+ OMPC_capture,
+ OMPC_collapse,
+ OMPC_copyprivate,
+ OMPC_copyin,
+ OMPC_default,
+ OMPC_defaultmap,
+ OMPC_depend,
+ OMPC_depobj,
+ OMPC_destroy,
+ OMPC_detach,
+ OMPC_device,
+ OMPC_device_type,
+ OMPC_dist_schedule,
+ OMPC_dynamic_allocators,
+ OMPC_exclusive,
+ OMPC_final,
+ OMPC_firstprivate,
+ OMPC_flush,
+ OMPC_from,
+ OMPC_grainsize,
+ OMPC_hint,
+ OMPC_if,
+ OMPC_in_reduction,
+ OMPC_inbranch,
+ OMPC_inclusive,
+ OMPC_is_device_ptr,
+ OMPC_lastprivate,
+ OMPC_linear,
+ OMPC_link,
+ OMPC_map,
+ OMPC_match,
+ OMPC_mergeable,
+ OMPC_nogroup,
+ OMPC_nowait,
+ OMPC_nontemporal,
+ OMPC_notinbranch,
+ OMPC_num_tasks,
+ OMPC_num_teams,
+ OMPC_num_threads,
+ OMPC_order,
+ OMPC_ordered,
+ OMPC_priority,
+ OMPC_private,
+ OMPC_proc_bind,
+ OMPC_read,
+ OMPC_reduction,
+ OMPC_relaxed,
+ OMPC_release,
+ OMPC_reverse_offload,
+ OMPC_safelen,
+ OMPC_schedule,
+ OMPC_seq_cst,
+ OMPC_shared,
+ OMPC_simd,
+ OMPC_simdlen,
+ OMPC_task_reduction,
+ OMPC_thread_limit,
+ OMPC_threadprivate,
+ OMPC_threads,
+ OMPC_to,
+ OMPC_unified_address,
+ OMPC_unified_shared_memory,
+ OMPC_uniform,
+ OMPC_unknown,
+ OMPC_untied,
+ OMPC_update,
+ OMPC_use_device_addr,
+ OMPC_use_device_ptr,
+ OMPC_uses_allocators,
+ OMPC_write,
+};
+
+static constexpr std::size_t Clause_enumSize = 77;
+
+constexpr auto OMPC_acq_rel = llvm::omp::Clause::OMPC_acq_rel;
+constexpr auto OMPC_acquire = llvm::omp::Clause::OMPC_acquire;
+constexpr auto OMPC_affinity = llvm::omp::Clause::OMPC_affinity;
+constexpr auto OMPC_aligned = llvm::omp::Clause::OMPC_aligned;
+constexpr auto OMPC_allocate = llvm::omp::Clause::OMPC_allocate;
+constexpr auto OMPC_allocator = llvm::omp::Clause::OMPC_allocator;
+constexpr auto OMPC_atomic_default_mem_order = llvm::omp::Clause::OMPC_atomic_default_mem_order;
+constexpr auto OMPC_capture = llvm::omp::Clause::OMPC_capture;
+constexpr auto OMPC_collapse = llvm::omp::Clause::OMPC_collapse;
+constexpr auto OMPC_copyprivate = llvm::omp::Clause::OMPC_copyprivate;
+constexpr auto OMPC_copyin = llvm::omp::Clause::OMPC_copyin;
+constexpr auto OMPC_default = llvm::omp::Clause::OMPC_default;
+constexpr auto OMPC_defaultmap = llvm::omp::Clause::OMPC_defaultmap;
+constexpr auto OMPC_depend = llvm::omp::Clause::OMPC_depend;
+constexpr auto OMPC_depobj = llvm::omp::Clause::OMPC_depobj;
+constexpr auto OMPC_destroy = llvm::omp::Clause::OMPC_destroy;
+constexpr auto OMPC_detach = llvm::omp::Clause::OMPC_detach;
+constexpr auto OMPC_device = llvm::omp::Clause::OMPC_device;
+constexpr auto OMPC_device_type = llvm::omp::Clause::OMPC_device_type;
+constexpr auto OMPC_dist_schedule = llvm::omp::Clause::OMPC_dist_schedule;
+constexpr auto OMPC_dynamic_allocators = llvm::omp::Clause::OMPC_dynamic_allocators;
+constexpr auto OMPC_exclusive = llvm::omp::Clause::OMPC_exclusive;
+constexpr auto OMPC_final = llvm::omp::Clause::OMPC_final;
+constexpr auto OMPC_firstprivate = llvm::omp::Clause::OMPC_firstprivate;
+constexpr auto OMPC_flush = llvm::omp::Clause::OMPC_flush;
+constexpr auto OMPC_from = llvm::omp::Clause::OMPC_from;
+constexpr auto OMPC_grainsize = llvm::omp::Clause::OMPC_grainsize;
+constexpr auto OMPC_hint = llvm::omp::Clause::OMPC_hint;
+constexpr auto OMPC_if = llvm::omp::Clause::OMPC_if;
+constexpr auto OMPC_in_reduction = llvm::omp::Clause::OMPC_in_reduction;
+constexpr auto OMPC_inbranch = llvm::omp::Clause::OMPC_inbranch;
+constexpr auto OMPC_inclusive = llvm::omp::Clause::OMPC_inclusive;
+constexpr auto OMPC_is_device_ptr = llvm::omp::Clause::OMPC_is_device_ptr;
+constexpr auto OMPC_lastprivate = llvm::omp::Clause::OMPC_lastprivate;
+constexpr auto OMPC_linear = llvm::omp::Clause::OMPC_linear;
+constexpr auto OMPC_link = llvm::omp::Clause::OMPC_link;
+constexpr auto OMPC_map = llvm::omp::Clause::OMPC_map;
+constexpr auto OMPC_match = llvm::omp::Clause::OMPC_match;
+constexpr auto OMPC_mergeable = llvm::omp::Clause::OMPC_mergeable;
+constexpr auto OMPC_nogroup = llvm::omp::Clause::OMPC_nogroup;
+constexpr auto OMPC_nowait = llvm::omp::Clause::OMPC_nowait;
+constexpr auto OMPC_nontemporal = llvm::omp::Clause::OMPC_nontemporal;
+constexpr auto OMPC_notinbranch = llvm::omp::Clause::OMPC_notinbranch;
+constexpr auto OMPC_num_tasks = llvm::omp::Clause::OMPC_num_tasks;
+constexpr auto OMPC_num_teams = llvm::omp::Clause::OMPC_num_teams;
+constexpr auto OMPC_num_threads = llvm::omp::Clause::OMPC_num_threads;
+constexpr auto OMPC_order = llvm::omp::Clause::OMPC_order;
+constexpr auto OMPC_ordered = llvm::omp::Clause::OMPC_ordered;
+constexpr auto OMPC_priority = llvm::omp::Clause::OMPC_priority;
+constexpr auto OMPC_private = llvm::omp::Clause::OMPC_private;
+constexpr auto OMPC_proc_bind = llvm::omp::Clause::OMPC_proc_bind;
+constexpr auto OMPC_read = llvm::omp::Clause::OMPC_read;
+constexpr auto OMPC_reduction = llvm::omp::Clause::OMPC_reduction;
+constexpr auto OMPC_relaxed = llvm::omp::Clause::OMPC_relaxed;
+constexpr auto OMPC_release = llvm::omp::Clause::OMPC_release;
+constexpr auto OMPC_reverse_offload = llvm::omp::Clause::OMPC_reverse_offload;
+constexpr auto OMPC_safelen = llvm::omp::Clause::OMPC_safelen;
+constexpr auto OMPC_schedule = llvm::omp::Clause::OMPC_schedule;
+constexpr auto OMPC_seq_cst = llvm::omp::Clause::OMPC_seq_cst;
+constexpr auto OMPC_shared = llvm::omp::Clause::OMPC_shared;
+constexpr auto OMPC_simd = llvm::omp::Clause::OMPC_simd;
+constexpr auto OMPC_simdlen = llvm::omp::Clause::OMPC_simdlen;
+constexpr auto OMPC_task_reduction = llvm::omp::Clause::OMPC_task_reduction;
+constexpr auto OMPC_thread_limit = llvm::omp::Clause::OMPC_thread_limit;
+constexpr auto OMPC_threadprivate = llvm::omp::Clause::OMPC_threadprivate;
+constexpr auto OMPC_threads = llvm::omp::Clause::OMPC_threads;
+constexpr auto OMPC_to = llvm::omp::Clause::OMPC_to;
+constexpr auto OMPC_unified_address = llvm::omp::Clause::OMPC_unified_address;
+constexpr auto OMPC_unified_shared_memory = llvm::omp::Clause::OMPC_unified_shared_memory;
+constexpr auto OMPC_uniform = llvm::omp::Clause::OMPC_uniform;
+constexpr auto OMPC_unknown = llvm::omp::Clause::OMPC_unknown;
+constexpr auto OMPC_untied = llvm::omp::Clause::OMPC_untied;
+constexpr auto OMPC_update = llvm::omp::Clause::OMPC_update;
+constexpr auto OMPC_use_device_addr = llvm::omp::Clause::OMPC_use_device_addr;
+constexpr auto OMPC_use_device_ptr = llvm::omp::Clause::OMPC_use_device_ptr;
+constexpr auto OMPC_uses_allocators = llvm::omp::Clause::OMPC_uses_allocators;
+constexpr auto OMPC_write = llvm::omp::Clause::OMPC_write;
+
+enum class OrderKind {
+ OMP_ORDER_concurrent=2,
+};
+
+constexpr auto OMP_ORDER_concurrent = llvm::omp::OrderKind::OMP_ORDER_concurrent;
+
+enum class ProcBindKind {
+ OMP_PROC_BIND_master=2,
+ OMP_PROC_BIND_close=3,
+ OMP_PROC_BIND_spread=4,
+ OMP_PROC_BIND_default=5,
+ OMP_PROC_BIND_unknown=6,
+};
+
+constexpr auto OMP_PROC_BIND_master = llvm::omp::ProcBindKind::OMP_PROC_BIND_master;
+constexpr auto OMP_PROC_BIND_close = llvm::omp::ProcBindKind::OMP_PROC_BIND_close;
+constexpr auto OMP_PROC_BIND_spread = llvm::omp::ProcBindKind::OMP_PROC_BIND_spread;
+constexpr auto OMP_PROC_BIND_default = llvm::omp::ProcBindKind::OMP_PROC_BIND_default;
+constexpr auto OMP_PROC_BIND_unknown = llvm::omp::ProcBindKind::OMP_PROC_BIND_unknown;
+
+enum class ScheduleKind {
+ OMP_SCHEDULE_Static=2,
+ OMP_SCHEDULE_Dynamic=3,
+ OMP_SCHEDULE_Guided=4,
+ OMP_SCHEDULE_Auto=5,
+ OMP_SCHEDULE_Runtime=6,
+ OMP_SCHEDULE_Default=7,
+};
+
+constexpr auto OMP_SCHEDULE_Static = llvm::omp::ScheduleKind::OMP_SCHEDULE_Static;
+constexpr auto OMP_SCHEDULE_Dynamic = llvm::omp::ScheduleKind::OMP_SCHEDULE_Dynamic;
+constexpr auto OMP_SCHEDULE_Guided = llvm::omp::ScheduleKind::OMP_SCHEDULE_Guided;
+constexpr auto OMP_SCHEDULE_Auto = llvm::omp::ScheduleKind::OMP_SCHEDULE_Auto;
+constexpr auto OMP_SCHEDULE_Runtime = llvm::omp::ScheduleKind::OMP_SCHEDULE_Runtime;
+constexpr auto OMP_SCHEDULE_Default = llvm::omp::ScheduleKind::OMP_SCHEDULE_Default;
+
+// Enumeration helper functions
+Directive getOpenMPDirectiveKind(llvm::StringRef Str);
+
+llvm::StringRef getOpenMPDirectiveName(Directive D);
+
+Clause getOpenMPClauseKind(llvm::StringRef Str);
+
+llvm::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);
+
+OrderKind getOrderKind(StringRef);
+llvm::StringRef getOpenMPOrderKindName(OrderKind);
+ProcBindKind getProcBindKind(StringRef);
+llvm::StringRef getOpenMPProcBindKindName(ProcBindKind);
+ScheduleKind getScheduleKind(StringRef);
+llvm::StringRef getOpenMPScheduleKindName(ScheduleKind);
+
+} // namespace omp
+} // namespace llvm
+#endif // LLVM_OpenMP_INC
diff --git a/linux-x64/clang/include/llvm/Frontend/OpenMP/OMP.inc b/linux-x64/clang/include/llvm/Frontend/OpenMP/OMP.inc
new file mode 100644
index 0000000..80df71a
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Frontend/OpenMP/OMP.inc
@@ -0,0 +1,3451 @@
+#ifdef GEN_FLANG_DIRECTIVE_CLAUSE_SETS
+#undef GEN_FLANG_DIRECTIVE_CLAUSE_SETS
+
+namespace llvm {
+namespace omp {
+
+ // Sets for allocate
+
+ static OmpClauseSet allowedClauses_OMPD_allocate {
+ llvm::omp::Clause::OMPC_allocator,
+ };
+
+ static OmpClauseSet allowedOnceClauses_OMPD_allocate {
+ };
+
+ static OmpClauseSet allowedExclusiveClauses_OMPD_allocate {
+ };
+
+ static OmpClauseSet requiredClauses_OMPD_allocate {
+ };
+
+ // Sets for assumes
+
+ static OmpClauseSet allowedClauses_OMPD_assumes {
+ };
+
+ static OmpClauseSet allowedOnceClauses_OMPD_assumes {
+ };
+
+ static OmpClauseSet allowedExclusiveClauses_OMPD_assumes {
+ };
+
+ static OmpClauseSet requiredClauses_OMPD_assumes {
+ };
+
+ // Sets for atomic
+
+ static OmpClauseSet allowedClauses_OMPD_atomic {
+ llvm::omp::Clause::OMPC_read,
+ llvm::omp::Clause::OMPC_write,
+ llvm::omp::Clause::OMPC_update,
+ llvm::omp::Clause::OMPC_capture,
+ };
+
+ static OmpClauseSet allowedOnceClauses_OMPD_atomic {
+ llvm::omp::Clause::OMPC_seq_cst,
+ llvm::omp::Clause::OMPC_acq_rel,
+ llvm::omp::Clause::OMPC_acquire,
+ llvm::omp::Clause::OMPC_release,
+ llvm::omp::Clause::OMPC_relaxed,
+ llvm::omp::Clause::OMPC_hint,
+ };
+
+ static OmpClauseSet allowedExclusiveClauses_OMPD_atomic {
+ };
+
+ static OmpClauseSet requiredClauses_OMPD_atomic {
+ };
+
+ // Sets for barrier
+
+ static OmpClauseSet allowedClauses_OMPD_barrier {
+ };
+
+ static OmpClauseSet allowedOnceClauses_OMPD_barrier {
+ };
+
+ static OmpClauseSet allowedExclusiveClauses_OMPD_barrier {
+ };
+
+ static OmpClauseSet requiredClauses_OMPD_barrier {
+ };
+
+ // Sets for begin assumes
+
+ static OmpClauseSet allowedClauses_OMPD_begin_assumes {
+ };
+
+ static OmpClauseSet allowedOnceClauses_OMPD_begin_assumes {
+ };
+
+ static OmpClauseSet allowedExclusiveClauses_OMPD_begin_assumes {
+ };
+
+ static OmpClauseSet requiredClauses_OMPD_begin_assumes {
+ };
+
+ // Sets for begin declare variant
+
+ static OmpClauseSet allowedClauses_OMPD_begin_declare_variant {
+ };
+
+ static OmpClauseSet allowedOnceClauses_OMPD_begin_declare_variant {
+ };
+
+ static OmpClauseSet allowedExclusiveClauses_OMPD_begin_declare_variant {
+ };
+
+ static OmpClauseSet requiredClauses_OMPD_begin_declare_variant {
+ };
+
+ // Sets for cancel
+
+ static OmpClauseSet allowedClauses_OMPD_cancel {
+ llvm::omp::Clause::OMPC_if,
+ };
+
+ static OmpClauseSet allowedOnceClauses_OMPD_cancel {
+ };
+
+ static OmpClauseSet allowedExclusiveClauses_OMPD_cancel {
+ };
+
+ static OmpClauseSet requiredClauses_OMPD_cancel {
+ };
+
+ // Sets for cancellation point
+
+ static OmpClauseSet allowedClauses_OMPD_cancellation_point {
+ };
+
+ static OmpClauseSet allowedOnceClauses_OMPD_cancellation_point {
+ };
+
+ static OmpClauseSet allowedExclusiveClauses_OMPD_cancellation_point {
+ };
+
+ static OmpClauseSet requiredClauses_OMPD_cancellation_point {
+ };
+
+ // Sets for critical
+
+ static OmpClauseSet allowedClauses_OMPD_critical {
+ llvm::omp::Clause::OMPC_hint,
+ };
+
+ static OmpClauseSet allowedOnceClauses_OMPD_critical {
+ };
+
+ static OmpClauseSet allowedExclusiveClauses_OMPD_critical {
+ };
+
+ static OmpClauseSet requiredClauses_OMPD_critical {
+ };
+
+ // Sets for declare mapper
+
+ static OmpClauseSet allowedClauses_OMPD_declare_mapper {
+ llvm::omp::Clause::OMPC_map,
+ };
+
+ static OmpClauseSet allowedOnceClauses_OMPD_declare_mapper {
+ };
+
+ static OmpClauseSet allowedExclusiveClauses_OMPD_declare_mapper {
+ };
+
+ static OmpClauseSet requiredClauses_OMPD_declare_mapper {
+ };
+
+ // Sets for declare reduction
+
+ static OmpClauseSet allowedClauses_OMPD_declare_reduction {
+ };
+
+ static OmpClauseSet allowedOnceClauses_OMPD_declare_reduction {
+ };
+
+ static OmpClauseSet allowedExclusiveClauses_OMPD_declare_reduction {
+ };
+
+ static OmpClauseSet requiredClauses_OMPD_declare_reduction {
+ };
+
+ // Sets for declare simd
+
+ static OmpClauseSet allowedClauses_OMPD_declare_simd {
+ llvm::omp::Clause::OMPC_linear,
+ llvm::omp::Clause::OMPC_aligned,
+ llvm::omp::Clause::OMPC_uniform,
+ };
+
+ static OmpClauseSet allowedOnceClauses_OMPD_declare_simd {
+ llvm::omp::Clause::OMPC_simdlen,
+ };
+
+ static OmpClauseSet allowedExclusiveClauses_OMPD_declare_simd {
+ llvm::omp::Clause::OMPC_inbranch,
+ llvm::omp::Clause::OMPC_notinbranch,
+ };
+
+ static OmpClauseSet requiredClauses_OMPD_declare_simd {
+ };
+
+ // Sets for declare target
+
+ static OmpClauseSet allowedClauses_OMPD_declare_target {
+ llvm::omp::Clause::OMPC_to,
+ llvm::omp::Clause::OMPC_link,
+ };
+
+ static OmpClauseSet allowedOnceClauses_OMPD_declare_target {
+ };
+
+ static OmpClauseSet allowedExclusiveClauses_OMPD_declare_target {
+ };
+
+ static OmpClauseSet requiredClauses_OMPD_declare_target {
+ };
+
+ // Sets for declare variant
+
+ static OmpClauseSet allowedClauses_OMPD_declare_variant {
+ llvm::omp::Clause::OMPC_match,
+ };
+
+ static OmpClauseSet allowedOnceClauses_OMPD_declare_variant {
+ };
+
+ static OmpClauseSet allowedExclusiveClauses_OMPD_declare_variant {
+ };
+
+ static OmpClauseSet requiredClauses_OMPD_declare_variant {
+ };
+
+ // Sets for depobj
+
+ static OmpClauseSet allowedClauses_OMPD_depobj {
+ llvm::omp::Clause::OMPC_depend,
+ llvm::omp::Clause::OMPC_destroy,
+ llvm::omp::Clause::OMPC_update,
+ llvm::omp::Clause::OMPC_depobj,
+ };
+
+ static OmpClauseSet allowedOnceClauses_OMPD_depobj {
+ };
+
+ static OmpClauseSet allowedExclusiveClauses_OMPD_depobj {
+ };
+
+ static OmpClauseSet requiredClauses_OMPD_depobj {
+ };
+
+ // Sets for distribute
+
+ static OmpClauseSet allowedClauses_OMPD_distribute {
+ llvm::omp::Clause::OMPC_private,
+ llvm::omp::Clause::OMPC_firstprivate,
+ llvm::omp::Clause::OMPC_lastprivate,
+ llvm::omp::Clause::OMPC_allocate,
+ };
+
+ static OmpClauseSet allowedOnceClauses_OMPD_distribute {
+ llvm::omp::Clause::OMPC_collapse,
+ llvm::omp::Clause::OMPC_dist_schedule,
+ };
+
+ static OmpClauseSet allowedExclusiveClauses_OMPD_distribute {
+ };
+
+ static OmpClauseSet requiredClauses_OMPD_distribute {
+ };
+
+ // Sets for distribute parallel do
+
+ static OmpClauseSet allowedClauses_OMPD_distribute_parallel_do {
+ llvm::omp::Clause::OMPC_private,
+ llvm::omp::Clause::OMPC_firstprivate,
+ llvm::omp::Clause::OMPC_lastprivate,
+ llvm::omp::Clause::OMPC_allocate,
+ llvm::omp::Clause::OMPC_order,
+ llvm::omp::Clause::OMPC_default,
+ llvm::omp::Clause::OMPC_shared,
+ llvm::omp::Clause::OMPC_reduction,
+ llvm::omp::Clause::OMPC_copyin,
+ llvm::omp::Clause::OMPC_linear,
+ };
+
+ static OmpClauseSet allowedOnceClauses_OMPD_distribute_parallel_do {
+ llvm::omp::Clause::OMPC_collapse,
+ llvm::omp::Clause::OMPC_dist_schedule,
+ llvm::omp::Clause::OMPC_if,
+ llvm::omp::Clause::OMPC_num_threads,
+ llvm::omp::Clause::OMPC_proc_bind,
+ llvm::omp::Clause::OMPC_schedule,
+ llvm::omp::Clause::OMPC_ordered,
+ };
+
+ static OmpClauseSet allowedExclusiveClauses_OMPD_distribute_parallel_do {
+ };
+
+ static OmpClauseSet requiredClauses_OMPD_distribute_parallel_do {
+ };
+
+ // Sets for distribute parallel do simd
+
+ static OmpClauseSet allowedClauses_OMPD_distribute_parallel_do_simd {
+ llvm::omp::Clause::OMPC_firstprivate,
+ llvm::omp::Clause::OMPC_lastprivate,
+ llvm::omp::Clause::OMPC_collapse,
+ llvm::omp::Clause::OMPC_dist_schedule,
+ llvm::omp::Clause::OMPC_if,
+ llvm::omp::Clause::OMPC_num_threads,
+ llvm::omp::Clause::OMPC_default,
+ llvm::omp::Clause::OMPC_proc_bind,
+ llvm::omp::Clause::OMPC_private,
+ llvm::omp::Clause::OMPC_shared,
+ llvm::omp::Clause::OMPC_reduction,
+ llvm::omp::Clause::OMPC_copyin,
+ llvm::omp::Clause::OMPC_schedule,
+ llvm::omp::Clause::OMPC_linear,
+ llvm::omp::Clause::OMPC_aligned,
+ llvm::omp::Clause::OMPC_safelen,
+ llvm::omp::Clause::OMPC_simdlen,
+ llvm::omp::Clause::OMPC_allocate,
+ llvm::omp::Clause::OMPC_nontemporal,
+ llvm::omp::Clause::OMPC_order,
+ };
+
+ static OmpClauseSet allowedOnceClauses_OMPD_distribute_parallel_do_simd {
+ };
+
+ static OmpClauseSet allowedExclusiveClauses_OMPD_distribute_parallel_do_simd {
+ };
+
+ static OmpClauseSet requiredClauses_OMPD_distribute_parallel_do_simd {
+ };
+
+ // Sets for distribute parallel for
+
+ static OmpClauseSet allowedClauses_OMPD_distribute_parallel_for {
+ llvm::omp::Clause::OMPC_firstprivate,
+ llvm::omp::Clause::OMPC_lastprivate,
+ llvm::omp::Clause::OMPC_collapse,
+ llvm::omp::Clause::OMPC_dist_schedule,
+ llvm::omp::Clause::OMPC_if,
+ llvm::omp::Clause::OMPC_num_threads,
+ llvm::omp::Clause::OMPC_default,
+ llvm::omp::Clause::OMPC_proc_bind,
+ llvm::omp::Clause::OMPC_private,
+ llvm::omp::Clause::OMPC_shared,
+ llvm::omp::Clause::OMPC_reduction,
+ llvm::omp::Clause::OMPC_copyin,
+ llvm::omp::Clause::OMPC_schedule,
+ llvm::omp::Clause::OMPC_allocate,
+ llvm::omp::Clause::OMPC_order,
+ };
+
+ static OmpClauseSet allowedOnceClauses_OMPD_distribute_parallel_for {
+ };
+
+ static OmpClauseSet allowedExclusiveClauses_OMPD_distribute_parallel_for {
+ };
+
+ static OmpClauseSet requiredClauses_OMPD_distribute_parallel_for {
+ };
+
+ // Sets for distribute parallel for simd
+
+ static OmpClauseSet allowedClauses_OMPD_distribute_parallel_for_simd {
+ llvm::omp::Clause::OMPC_firstprivate,
+ llvm::omp::Clause::OMPC_lastprivate,
+ llvm::omp::Clause::OMPC_collapse,
+ llvm::omp::Clause::OMPC_dist_schedule,
+ llvm::omp::Clause::OMPC_if,
+ llvm::omp::Clause::OMPC_num_threads,
+ llvm::omp::Clause::OMPC_default,
+ llvm::omp::Clause::OMPC_proc_bind,
+ llvm::omp::Clause::OMPC_private,
+ llvm::omp::Clause::OMPC_shared,
+ llvm::omp::Clause::OMPC_reduction,
+ llvm::omp::Clause::OMPC_copyin,
+ llvm::omp::Clause::OMPC_schedule,
+ llvm::omp::Clause::OMPC_linear,
+ llvm::omp::Clause::OMPC_aligned,
+ llvm::omp::Clause::OMPC_safelen,
+ llvm::omp::Clause::OMPC_simdlen,
+ llvm::omp::Clause::OMPC_allocate,
+ llvm::omp::Clause::OMPC_nontemporal,
+ llvm::omp::Clause::OMPC_order,
+ };
+
+ static OmpClauseSet allowedOnceClauses_OMPD_distribute_parallel_for_simd {
+ };
+
+ static OmpClauseSet allowedExclusiveClauses_OMPD_distribute_parallel_for_simd {
+ };
+
+ static OmpClauseSet requiredClauses_OMPD_distribute_parallel_for_simd {
+ };
+
+ // Sets for distribute simd
+
+ static OmpClauseSet allowedClauses_OMPD_distribute_simd {
+ llvm::omp::Clause::OMPC_aligned,
+ llvm::omp::Clause::OMPC_allocate,
+ llvm::omp::Clause::OMPC_copyin,
+ llvm::omp::Clause::OMPC_default,
+ llvm::omp::Clause::OMPC_linear,
+ llvm::omp::Clause::OMPC_firstprivate,
+ llvm::omp::Clause::OMPC_lastprivate,
+ llvm::omp::Clause::OMPC_nontemporal,
+ llvm::omp::Clause::OMPC_order,
+ llvm::omp::Clause::OMPC_private,
+ llvm::omp::Clause::OMPC_reduction,
+ };
+
+ static OmpClauseSet allowedOnceClauses_OMPD_distribute_simd {
+ llvm::omp::Clause::OMPC_collapse,
+ llvm::omp::Clause::OMPC_dist_schedule,
+ llvm::omp::Clause::OMPC_if,
+ llvm::omp::Clause::OMPC_num_threads,
+ llvm::omp::Clause::OMPC_ordered,
+ llvm::omp::Clause::OMPC_proc_bind,
+ llvm::omp::Clause::OMPC_schedule,
+ llvm::omp::Clause::OMPC_safelen,
+ llvm::omp::Clause::OMPC_simdlen,
+ };
+
+ static OmpClauseSet allowedExclusiveClauses_OMPD_distribute_simd {
+ };
+
+ static OmpClauseSet requiredClauses_OMPD_distribute_simd {
+ };
+
+ // Sets for do
+
+ static OmpClauseSet allowedClauses_OMPD_do {
+ llvm::omp::Clause::OMPC_private,
+ llvm::omp::Clause::OMPC_firstprivate,
+ llvm::omp::Clause::OMPC_lastprivate,
+ llvm::omp::Clause::OMPC_linear,
+ llvm::omp::Clause::OMPC_reduction,
+ };
+
+ static OmpClauseSet allowedOnceClauses_OMPD_do {
+ llvm::omp::Clause::OMPC_schedule,
+ llvm::omp::Clause::OMPC_collapse,
+ llvm::omp::Clause::OMPC_ordered,
+ llvm::omp::Clause::OMPC_nowait,
+ };
+
+ static OmpClauseSet allowedExclusiveClauses_OMPD_do {
+ };
+
+ static OmpClauseSet requiredClauses_OMPD_do {
+ };
+
+ // Sets for do simd
+
+ static OmpClauseSet allowedClauses_OMPD_do_simd {
+ llvm::omp::Clause::OMPC_aligned,
+ llvm::omp::Clause::OMPC_private,
+ llvm::omp::Clause::OMPC_firstprivate,
+ llvm::omp::Clause::OMPC_lastprivate,
+ llvm::omp::Clause::OMPC_linear,
+ llvm::omp::Clause::OMPC_reduction,
+ };
+
+ static OmpClauseSet allowedOnceClauses_OMPD_do_simd {
+ llvm::omp::Clause::OMPC_schedule,
+ llvm::omp::Clause::OMPC_collapse,
+ llvm::omp::Clause::OMPC_ordered,
+ llvm::omp::Clause::OMPC_safelen,
+ llvm::omp::Clause::OMPC_simdlen,
+ llvm::omp::Clause::OMPC_nowait,
+ };
+
+ static OmpClauseSet allowedExclusiveClauses_OMPD_do_simd {
+ };
+
+ static OmpClauseSet requiredClauses_OMPD_do_simd {
+ };
+
+ // Sets for end assumes
+
+ static OmpClauseSet allowedClauses_OMPD_end_assumes {
+ };
+
+ static OmpClauseSet allowedOnceClauses_OMPD_end_assumes {
+ };
+
+ static OmpClauseSet allowedExclusiveClauses_OMPD_end_assumes {
+ };
+
+ static OmpClauseSet requiredClauses_OMPD_end_assumes {
+ };
+
+ // Sets for end declare target
+
+ static OmpClauseSet allowedClauses_OMPD_end_declare_target {
+ };
+
+ static OmpClauseSet allowedOnceClauses_OMPD_end_declare_target {
+ };
+
+ static OmpClauseSet allowedExclusiveClauses_OMPD_end_declare_target {
+ };
+
+ static OmpClauseSet requiredClauses_OMPD_end_declare_target {
+ };
+
+ // Sets for end declare variant
+
+ static OmpClauseSet allowedClauses_OMPD_end_declare_variant {
+ };
+
+ static OmpClauseSet allowedOnceClauses_OMPD_end_declare_variant {
+ };
+
+ static OmpClauseSet allowedExclusiveClauses_OMPD_end_declare_variant {
+ };
+
+ static OmpClauseSet requiredClauses_OMPD_end_declare_variant {
+ };
+
+ // Sets for end do
+
+ static OmpClauseSet allowedClauses_OMPD_end_do {
+ };
+
+ static OmpClauseSet allowedOnceClauses_OMPD_end_do {
+ };
+
+ static OmpClauseSet allowedExclusiveClauses_OMPD_end_do {
+ };
+
+ static OmpClauseSet requiredClauses_OMPD_end_do {
+ };
+
+ // Sets for end do simd
+
+ static OmpClauseSet allowedClauses_OMPD_end_do_simd {
+ };
+
+ static OmpClauseSet allowedOnceClauses_OMPD_end_do_simd {
+ };
+
+ static OmpClauseSet allowedExclusiveClauses_OMPD_end_do_simd {
+ };
+
+ static OmpClauseSet requiredClauses_OMPD_end_do_simd {
+ };
+
+ // Sets for end sections
+
+ static OmpClauseSet allowedClauses_OMPD_end_sections {
+ };
+
+ static OmpClauseSet allowedOnceClauses_OMPD_end_sections {
+ llvm::omp::Clause::OMPC_nowait,
+ };
+
+ static OmpClauseSet allowedExclusiveClauses_OMPD_end_sections {
+ };
+
+ static OmpClauseSet requiredClauses_OMPD_end_sections {
+ };
+
+ // Sets for end single
+
+ static OmpClauseSet allowedClauses_OMPD_end_single {
+ llvm::omp::Clause::OMPC_copyprivate,
+ };
+
+ static OmpClauseSet allowedOnceClauses_OMPD_end_single {
+ llvm::omp::Clause::OMPC_nowait,
+ };
+
+ static OmpClauseSet allowedExclusiveClauses_OMPD_end_single {
+ };
+
+ static OmpClauseSet requiredClauses_OMPD_end_single {
+ };
+
+ // Sets for end workshare
+
+ static OmpClauseSet allowedClauses_OMPD_end_workshare {
+ llvm::omp::Clause::OMPC_nowait,
+ };
+
+ static OmpClauseSet allowedOnceClauses_OMPD_end_workshare {
+ };
+
+ static OmpClauseSet allowedExclusiveClauses_OMPD_end_workshare {
+ };
+
+ static OmpClauseSet requiredClauses_OMPD_end_workshare {
+ };
+
+ // Sets for flush
+
+ static OmpClauseSet allowedClauses_OMPD_flush {
+ };
+
+ static OmpClauseSet allowedOnceClauses_OMPD_flush {
+ llvm::omp::Clause::OMPC_acq_rel,
+ llvm::omp::Clause::OMPC_acquire,
+ llvm::omp::Clause::OMPC_release,
+ llvm::omp::Clause::OMPC_flush,
+ };
+
+ static OmpClauseSet allowedExclusiveClauses_OMPD_flush {
+ };
+
+ static OmpClauseSet requiredClauses_OMPD_flush {
+ };
+
+ // Sets for for
+
+ static OmpClauseSet allowedClauses_OMPD_for {
+ llvm::omp::Clause::OMPC_private,
+ llvm::omp::Clause::OMPC_lastprivate,
+ llvm::omp::Clause::OMPC_firstprivate,
+ llvm::omp::Clause::OMPC_reduction,
+ llvm::omp::Clause::OMPC_collapse,
+ llvm::omp::Clause::OMPC_schedule,
+ llvm::omp::Clause::OMPC_ordered,
+ llvm::omp::Clause::OMPC_nowait,
+ llvm::omp::Clause::OMPC_linear,
+ llvm::omp::Clause::OMPC_allocate,
+ llvm::omp::Clause::OMPC_order,
+ };
+
+ static OmpClauseSet allowedOnceClauses_OMPD_for {
+ };
+
+ static OmpClauseSet allowedExclusiveClauses_OMPD_for {
+ };
+
+ static OmpClauseSet requiredClauses_OMPD_for {
+ };
+
+ // Sets for for simd
+
+ static OmpClauseSet allowedClauses_OMPD_for_simd {
+ llvm::omp::Clause::OMPC_private,
+ llvm::omp::Clause::OMPC_firstprivate,
+ llvm::omp::Clause::OMPC_lastprivate,
+ llvm::omp::Clause::OMPC_reduction,
+ llvm::omp::Clause::OMPC_schedule,
+ llvm::omp::Clause::OMPC_collapse,
+ llvm::omp::Clause::OMPC_nowait,
+ llvm::omp::Clause::OMPC_safelen,
+ llvm::omp::Clause::OMPC_simdlen,
+ llvm::omp::Clause::OMPC_linear,
+ llvm::omp::Clause::OMPC_aligned,
+ llvm::omp::Clause::OMPC_ordered,
+ llvm::omp::Clause::OMPC_allocate,
+ llvm::omp::Clause::OMPC_if,
+ llvm::omp::Clause::OMPC_nontemporal,
+ llvm::omp::Clause::OMPC_order,
+ };
+
+ static OmpClauseSet allowedOnceClauses_OMPD_for_simd {
+ };
+
+ static OmpClauseSet allowedExclusiveClauses_OMPD_for_simd {
+ };
+
+ static OmpClauseSet requiredClauses_OMPD_for_simd {
+ };
+
+ // Sets for master
+
+ static OmpClauseSet allowedClauses_OMPD_master {
+ };
+
+ static OmpClauseSet allowedOnceClauses_OMPD_master {
+ };
+
+ static OmpClauseSet allowedExclusiveClauses_OMPD_master {
+ };
+
+ static OmpClauseSet requiredClauses_OMPD_master {
+ };
+
+ // Sets for master taskloop
+
+ static OmpClauseSet allowedClauses_OMPD_master_taskloop {
+ llvm::omp::Clause::OMPC_if,
+ llvm::omp::Clause::OMPC_shared,
+ llvm::omp::Clause::OMPC_private,
+ llvm::omp::Clause::OMPC_firstprivate,
+ llvm::omp::Clause::OMPC_lastprivate,
+ llvm::omp::Clause::OMPC_default,
+ llvm::omp::Clause::OMPC_collapse,
+ llvm::omp::Clause::OMPC_final,
+ llvm::omp::Clause::OMPC_untied,
+ llvm::omp::Clause::OMPC_mergeable,
+ llvm::omp::Clause::OMPC_priority,
+ llvm::omp::Clause::OMPC_grainsize,
+ llvm::omp::Clause::OMPC_nogroup,
+ llvm::omp::Clause::OMPC_num_tasks,
+ llvm::omp::Clause::OMPC_reduction,
+ llvm::omp::Clause::OMPC_in_reduction,
+ llvm::omp::Clause::OMPC_allocate,
+ };
+
+ static OmpClauseSet allowedOnceClauses_OMPD_master_taskloop {
+ };
+
+ static OmpClauseSet allowedExclusiveClauses_OMPD_master_taskloop {
+ };
+
+ static OmpClauseSet requiredClauses_OMPD_master_taskloop {
+ };
+
+ // Sets for master taskloop simd
+
+ static OmpClauseSet allowedClauses_OMPD_master_taskloop_simd {
+ llvm::omp::Clause::OMPC_if,
+ llvm::omp::Clause::OMPC_shared,
+ llvm::omp::Clause::OMPC_private,
+ llvm::omp::Clause::OMPC_firstprivate,
+ llvm::omp::Clause::OMPC_lastprivate,
+ llvm::omp::Clause::OMPC_default,
+ llvm::omp::Clause::OMPC_collapse,
+ llvm::omp::Clause::OMPC_final,
+ llvm::omp::Clause::OMPC_untied,
+ llvm::omp::Clause::OMPC_mergeable,
+ llvm::omp::Clause::OMPC_priority,
+ llvm::omp::Clause::OMPC_linear,
+ llvm::omp::Clause::OMPC_aligned,
+ llvm::omp::Clause::OMPC_safelen,
+ llvm::omp::Clause::OMPC_simdlen,
+ llvm::omp::Clause::OMPC_grainsize,
+ llvm::omp::Clause::OMPC_nogroup,
+ llvm::omp::Clause::OMPC_num_tasks,
+ llvm::omp::Clause::OMPC_reduction,
+ llvm::omp::Clause::OMPC_in_reduction,
+ llvm::omp::Clause::OMPC_allocate,
+ llvm::omp::Clause::OMPC_nontemporal,
+ llvm::omp::Clause::OMPC_order,
+ };
+
+ static OmpClauseSet allowedOnceClauses_OMPD_master_taskloop_simd {
+ };
+
+ static OmpClauseSet allowedExclusiveClauses_OMPD_master_taskloop_simd {
+ };
+
+ static OmpClauseSet requiredClauses_OMPD_master_taskloop_simd {
+ };
+
+ // Sets for ordered
+
+ static OmpClauseSet allowedClauses_OMPD_ordered {
+ llvm::omp::Clause::OMPC_threads,
+ llvm::omp::Clause::OMPC_simd,
+ llvm::omp::Clause::OMPC_depend,
+ };
+
+ static OmpClauseSet allowedOnceClauses_OMPD_ordered {
+ };
+
+ static OmpClauseSet allowedExclusiveClauses_OMPD_ordered {
+ };
+
+ static OmpClauseSet requiredClauses_OMPD_ordered {
+ };
+
+ // Sets for parallel
+
+ static OmpClauseSet allowedClauses_OMPD_parallel {
+ llvm::omp::Clause::OMPC_private,
+ llvm::omp::Clause::OMPC_firstprivate,
+ llvm::omp::Clause::OMPC_shared,
+ llvm::omp::Clause::OMPC_reduction,
+ llvm::omp::Clause::OMPC_copyin,
+ llvm::omp::Clause::OMPC_allocate,
+ };
+
+ static OmpClauseSet allowedOnceClauses_OMPD_parallel {
+ llvm::omp::Clause::OMPC_default,
+ llvm::omp::Clause::OMPC_if,
+ llvm::omp::Clause::OMPC_num_threads,
+ llvm::omp::Clause::OMPC_proc_bind,
+ };
+
+ static OmpClauseSet allowedExclusiveClauses_OMPD_parallel {
+ };
+
+ static OmpClauseSet requiredClauses_OMPD_parallel {
+ };
+
+ // Sets for parallel do
+
+ static OmpClauseSet allowedClauses_OMPD_parallel_do {
+ llvm::omp::Clause::OMPC_default,
+ llvm::omp::Clause::OMPC_private,
+ llvm::omp::Clause::OMPC_firstprivate,
+ llvm::omp::Clause::OMPC_shared,
+ llvm::omp::Clause::OMPC_reduction,
+ llvm::omp::Clause::OMPC_copyin,
+ llvm::omp::Clause::OMPC_lastprivate,
+ llvm::omp::Clause::OMPC_linear,
+ };
+
+ static OmpClauseSet allowedOnceClauses_OMPD_parallel_do {
+ llvm::omp::Clause::OMPC_if,
+ llvm::omp::Clause::OMPC_num_threads,
+ llvm::omp::Clause::OMPC_proc_bind,
+ llvm::omp::Clause::OMPC_schedule,
+ llvm::omp::Clause::OMPC_ordered,
+ llvm::omp::Clause::OMPC_collapse,
+ };
+
+ static OmpClauseSet allowedExclusiveClauses_OMPD_parallel_do {
+ };
+
+ static OmpClauseSet requiredClauses_OMPD_parallel_do {
+ };
+
+ // Sets for parallel do simd
+
+ static OmpClauseSet allowedClauses_OMPD_parallel_do_simd {
+ llvm::omp::Clause::OMPC_default,
+ llvm::omp::Clause::OMPC_private,
+ llvm::omp::Clause::OMPC_firstprivate,
+ llvm::omp::Clause::OMPC_shared,
+ llvm::omp::Clause::OMPC_reduction,
+ llvm::omp::Clause::OMPC_copyin,
+ llvm::omp::Clause::OMPC_lastprivate,
+ llvm::omp::Clause::OMPC_linear,
+ llvm::omp::Clause::OMPC_aligned,
+ llvm::omp::Clause::OMPC_allocate,
+ llvm::omp::Clause::OMPC_nontemporal,
+ llvm::omp::Clause::OMPC_order,
+ };
+
+ static OmpClauseSet allowedOnceClauses_OMPD_parallel_do_simd {
+ llvm::omp::Clause::OMPC_if,
+ llvm::omp::Clause::OMPC_num_threads,
+ llvm::omp::Clause::OMPC_proc_bind,
+ llvm::omp::Clause::OMPC_schedule,
+ llvm::omp::Clause::OMPC_ordered,
+ llvm::omp::Clause::OMPC_collapse,
+ llvm::omp::Clause::OMPC_safelen,
+ llvm::omp::Clause::OMPC_simdlen,
+ };
+
+ static OmpClauseSet allowedExclusiveClauses_OMPD_parallel_do_simd {
+ };
+
+ static OmpClauseSet requiredClauses_OMPD_parallel_do_simd {
+ };
+
+ // Sets for parallel for
+
+ static OmpClauseSet allowedClauses_OMPD_parallel_for {
+ llvm::omp::Clause::OMPC_if,
+ llvm::omp::Clause::OMPC_num_threads,
+ llvm::omp::Clause::OMPC_default,
+ llvm::omp::Clause::OMPC_proc_bind,
+ llvm::omp::Clause::OMPC_private,
+ llvm::omp::Clause::OMPC_firstprivate,
+ llvm::omp::Clause::OMPC_shared,
+ llvm::omp::Clause::OMPC_reduction,
+ llvm::omp::Clause::OMPC_copyin,
+ llvm::omp::Clause::OMPC_lastprivate,
+ llvm::omp::Clause::OMPC_collapse,
+ llvm::omp::Clause::OMPC_schedule,
+ llvm::omp::Clause::OMPC_ordered,
+ llvm::omp::Clause::OMPC_linear,
+ llvm::omp::Clause::OMPC_allocate,
+ llvm::omp::Clause::OMPC_order,
+ };
+
+ static OmpClauseSet allowedOnceClauses_OMPD_parallel_for {
+ };
+
+ static OmpClauseSet allowedExclusiveClauses_OMPD_parallel_for {
+ };
+
+ static OmpClauseSet requiredClauses_OMPD_parallel_for {
+ };
+
+ // Sets for parallel for simd
+
+ static OmpClauseSet allowedClauses_OMPD_parallel_for_simd {
+ llvm::omp::Clause::OMPC_if,
+ llvm::omp::Clause::OMPC_num_threads,
+ llvm::omp::Clause::OMPC_default,
+ llvm::omp::Clause::OMPC_proc_bind,
+ llvm::omp::Clause::OMPC_private,
+ llvm::omp::Clause::OMPC_firstprivate,
+ llvm::omp::Clause::OMPC_shared,
+ llvm::omp::Clause::OMPC_reduction,
+ llvm::omp::Clause::OMPC_copyin,
+ llvm::omp::Clause::OMPC_lastprivate,
+ llvm::omp::Clause::OMPC_collapse,
+ llvm::omp::Clause::OMPC_schedule,
+ llvm::omp::Clause::OMPC_safelen,
+ llvm::omp::Clause::OMPC_simdlen,
+ llvm::omp::Clause::OMPC_linear,
+ llvm::omp::Clause::OMPC_aligned,
+ llvm::omp::Clause::OMPC_ordered,
+ llvm::omp::Clause::OMPC_allocate,
+ llvm::omp::Clause::OMPC_nontemporal,
+ llvm::omp::Clause::OMPC_order,
+ };
+
+ static OmpClauseSet allowedOnceClauses_OMPD_parallel_for_simd {
+ };
+
+ static OmpClauseSet allowedExclusiveClauses_OMPD_parallel_for_simd {
+ };
+
+ static OmpClauseSet requiredClauses_OMPD_parallel_for_simd {
+ };
+
+ // Sets for parallel master
+
+ static OmpClauseSet allowedClauses_OMPD_parallel_master {
+ llvm::omp::Clause::OMPC_if,
+ llvm::omp::Clause::OMPC_num_threads,
+ llvm::omp::Clause::OMPC_default,
+ llvm::omp::Clause::OMPC_private,
+ llvm::omp::Clause::OMPC_firstprivate,
+ llvm::omp::Clause::OMPC_shared,
+ llvm::omp::Clause::OMPC_copyin,
+ llvm::omp::Clause::OMPC_reduction,
+ llvm::omp::Clause::OMPC_proc_bind,
+ llvm::omp::Clause::OMPC_allocate,
+ };
+
+ static OmpClauseSet allowedOnceClauses_OMPD_parallel_master {
+ };
+
+ static OmpClauseSet allowedExclusiveClauses_OMPD_parallel_master {
+ };
+
+ static OmpClauseSet requiredClauses_OMPD_parallel_master {
+ };
+
+ // Sets for parallel master taskloop
+
+ static OmpClauseSet allowedClauses_OMPD_parallel_master_taskloop {
+ llvm::omp::Clause::OMPC_if,
+ llvm::omp::Clause::OMPC_shared,
+ llvm::omp::Clause::OMPC_private,
+ llvm::omp::Clause::OMPC_firstprivate,
+ llvm::omp::Clause::OMPC_lastprivate,
+ llvm::omp::Clause::OMPC_default,
+ llvm::omp::Clause::OMPC_collapse,
+ llvm::omp::Clause::OMPC_final,
+ llvm::omp::Clause::OMPC_untied,
+ llvm::omp::Clause::OMPC_mergeable,
+ llvm::omp::Clause::OMPC_priority,
+ llvm::omp::Clause::OMPC_grainsize,
+ llvm::omp::Clause::OMPC_nogroup,
+ llvm::omp::Clause::OMPC_num_tasks,
+ llvm::omp::Clause::OMPC_reduction,
+ llvm::omp::Clause::OMPC_allocate,
+ llvm::omp::Clause::OMPC_num_threads,
+ llvm::omp::Clause::OMPC_proc_bind,
+ llvm::omp::Clause::OMPC_copyin,
+ };
+
+ static OmpClauseSet allowedOnceClauses_OMPD_parallel_master_taskloop {
+ };
+
+ static OmpClauseSet allowedExclusiveClauses_OMPD_parallel_master_taskloop {
+ };
+
+ static OmpClauseSet requiredClauses_OMPD_parallel_master_taskloop {
+ };
+
+ // Sets for parallel master taskloop simd
+
+ static OmpClauseSet allowedClauses_OMPD_parallel_master_taskloop_simd {
+ llvm::omp::Clause::OMPC_if,
+ llvm::omp::Clause::OMPC_shared,
+ llvm::omp::Clause::OMPC_private,
+ llvm::omp::Clause::OMPC_firstprivate,
+ llvm::omp::Clause::OMPC_lastprivate,
+ llvm::omp::Clause::OMPC_default,
+ llvm::omp::Clause::OMPC_collapse,
+ llvm::omp::Clause::OMPC_final,
+ llvm::omp::Clause::OMPC_untied,
+ llvm::omp::Clause::OMPC_mergeable,
+ llvm::omp::Clause::OMPC_priority,
+ llvm::omp::Clause::OMPC_grainsize,
+ llvm::omp::Clause::OMPC_nogroup,
+ llvm::omp::Clause::OMPC_num_tasks,
+ llvm::omp::Clause::OMPC_reduction,
+ llvm::omp::Clause::OMPC_allocate,
+ llvm::omp::Clause::OMPC_num_threads,
+ llvm::omp::Clause::OMPC_proc_bind,
+ llvm::omp::Clause::OMPC_copyin,
+ llvm::omp::Clause::OMPC_linear,
+ llvm::omp::Clause::OMPC_aligned,
+ llvm::omp::Clause::OMPC_safelen,
+ llvm::omp::Clause::OMPC_simdlen,
+ llvm::omp::Clause::OMPC_nontemporal,
+ llvm::omp::Clause::OMPC_order,
+ };
+
+ static OmpClauseSet allowedOnceClauses_OMPD_parallel_master_taskloop_simd {
+ };
+
+ static OmpClauseSet allowedExclusiveClauses_OMPD_parallel_master_taskloop_simd {
+ };
+
+ static OmpClauseSet requiredClauses_OMPD_parallel_master_taskloop_simd {
+ };
+
+ // Sets for parallel sections
+
+ static OmpClauseSet allowedClauses_OMPD_parallel_sections {
+ llvm::omp::Clause::OMPC_if,
+ llvm::omp::Clause::OMPC_default,
+ llvm::omp::Clause::OMPC_proc_bind,
+ llvm::omp::Clause::OMPC_private,
+ llvm::omp::Clause::OMPC_firstprivate,
+ llvm::omp::Clause::OMPC_shared,
+ llvm::omp::Clause::OMPC_reduction,
+ llvm::omp::Clause::OMPC_copyin,
+ llvm::omp::Clause::OMPC_lastprivate,
+ llvm::omp::Clause::OMPC_allocate,
+ };
+
+ static OmpClauseSet allowedOnceClauses_OMPD_parallel_sections {
+ llvm::omp::Clause::OMPC_num_threads,
+ };
+
+ static OmpClauseSet allowedExclusiveClauses_OMPD_parallel_sections {
+ };
+
+ static OmpClauseSet requiredClauses_OMPD_parallel_sections {
+ };
+
+ // Sets for parallel workshare
+
+ static OmpClauseSet allowedClauses_OMPD_parallel_workshare {
+ llvm::omp::Clause::OMPC_allocate,
+ llvm::omp::Clause::OMPC_copyin,
+ llvm::omp::Clause::OMPC_default,
+ llvm::omp::Clause::OMPC_firstprivate,
+ llvm::omp::Clause::OMPC_private,
+ llvm::omp::Clause::OMPC_reduction,
+ llvm::omp::Clause::OMPC_shared,
+ };
+
+ static OmpClauseSet allowedOnceClauses_OMPD_parallel_workshare {
+ llvm::omp::Clause::OMPC_if,
+ llvm::omp::Clause::OMPC_num_threads,
+ llvm::omp::Clause::OMPC_proc_bind,
+ };
+
+ static OmpClauseSet allowedExclusiveClauses_OMPD_parallel_workshare {
+ };
+
+ static OmpClauseSet requiredClauses_OMPD_parallel_workshare {
+ };
+
+ // Sets for requires
+
+ static OmpClauseSet allowedClauses_OMPD_requires {
+ llvm::omp::Clause::OMPC_unified_address,
+ llvm::omp::Clause::OMPC_unified_shared_memory,
+ llvm::omp::Clause::OMPC_reverse_offload,
+ llvm::omp::Clause::OMPC_dynamic_allocators,
+ llvm::omp::Clause::OMPC_atomic_default_mem_order,
+ };
+
+ static OmpClauseSet allowedOnceClauses_OMPD_requires {
+ };
+
+ static OmpClauseSet allowedExclusiveClauses_OMPD_requires {
+ };
+
+ static OmpClauseSet requiredClauses_OMPD_requires {
+ };
+
+ // Sets for scan
+
+ static OmpClauseSet allowedClauses_OMPD_scan {
+ llvm::omp::Clause::OMPC_inclusive,
+ llvm::omp::Clause::OMPC_exclusive,
+ };
+
+ static OmpClauseSet allowedOnceClauses_OMPD_scan {
+ };
+
+ static OmpClauseSet allowedExclusiveClauses_OMPD_scan {
+ };
+
+ static OmpClauseSet requiredClauses_OMPD_scan {
+ };
+
+ // Sets for section
+
+ static OmpClauseSet allowedClauses_OMPD_section {
+ };
+
+ static OmpClauseSet allowedOnceClauses_OMPD_section {
+ };
+
+ static OmpClauseSet allowedExclusiveClauses_OMPD_section {
+ };
+
+ static OmpClauseSet requiredClauses_OMPD_section {
+ };
+
+ // Sets for sections
+
+ static OmpClauseSet allowedClauses_OMPD_sections {
+ llvm::omp::Clause::OMPC_private,
+ llvm::omp::Clause::OMPC_lastprivate,
+ llvm::omp::Clause::OMPC_firstprivate,
+ llvm::omp::Clause::OMPC_reduction,
+ llvm::omp::Clause::OMPC_nowait,
+ llvm::omp::Clause::OMPC_allocate,
+ };
+
+ static OmpClauseSet allowedOnceClauses_OMPD_sections {
+ };
+
+ static OmpClauseSet allowedExclusiveClauses_OMPD_sections {
+ };
+
+ static OmpClauseSet requiredClauses_OMPD_sections {
+ };
+
+ // Sets for simd
+
+ static OmpClauseSet allowedClauses_OMPD_simd {
+ llvm::omp::Clause::OMPC_private,
+ llvm::omp::Clause::OMPC_lastprivate,
+ llvm::omp::Clause::OMPC_linear,
+ llvm::omp::Clause::OMPC_aligned,
+ llvm::omp::Clause::OMPC_reduction,
+ llvm::omp::Clause::OMPC_allocate,
+ llvm::omp::Clause::OMPC_nontemporal,
+ llvm::omp::Clause::OMPC_order,
+ };
+
+ static OmpClauseSet allowedOnceClauses_OMPD_simd {
+ llvm::omp::Clause::OMPC_collapse,
+ llvm::omp::Clause::OMPC_safelen,
+ llvm::omp::Clause::OMPC_simdlen,
+ llvm::omp::Clause::OMPC_if,
+ };
+
+ static OmpClauseSet allowedExclusiveClauses_OMPD_simd {
+ };
+
+ static OmpClauseSet requiredClauses_OMPD_simd {
+ };
+
+ // Sets for single
+
+ static OmpClauseSet allowedClauses_OMPD_single {
+ llvm::omp::Clause::OMPC_private,
+ llvm::omp::Clause::OMPC_firstprivate,
+ llvm::omp::Clause::OMPC_copyprivate,
+ llvm::omp::Clause::OMPC_nowait,
+ llvm::omp::Clause::OMPC_allocate,
+ };
+
+ static OmpClauseSet allowedOnceClauses_OMPD_single {
+ };
+
+ static OmpClauseSet allowedExclusiveClauses_OMPD_single {
+ };
+
+ static OmpClauseSet requiredClauses_OMPD_single {
+ };
+
+ // Sets for target
+
+ static OmpClauseSet allowedClauses_OMPD_target {
+ llvm::omp::Clause::OMPC_if,
+ llvm::omp::Clause::OMPC_map,
+ llvm::omp::Clause::OMPC_private,
+ llvm::omp::Clause::OMPC_depend,
+ llvm::omp::Clause::OMPC_firstprivate,
+ llvm::omp::Clause::OMPC_is_device_ptr,
+ llvm::omp::Clause::OMPC_reduction,
+ llvm::omp::Clause::OMPC_allocate,
+ llvm::omp::Clause::OMPC_uses_allocators,
+ };
+
+ static OmpClauseSet allowedOnceClauses_OMPD_target {
+ llvm::omp::Clause::OMPC_device,
+ llvm::omp::Clause::OMPC_defaultmap,
+ llvm::omp::Clause::OMPC_nowait,
+ };
+
+ static OmpClauseSet allowedExclusiveClauses_OMPD_target {
+ };
+
+ static OmpClauseSet requiredClauses_OMPD_target {
+ };
+
+ // Sets for target data
+
+ static OmpClauseSet allowedClauses_OMPD_target_data {
+ llvm::omp::Clause::OMPC_use_device_ptr,
+ llvm::omp::Clause::OMPC_use_device_addr,
+ };
+
+ static OmpClauseSet allowedOnceClauses_OMPD_target_data {
+ llvm::omp::Clause::OMPC_device,
+ llvm::omp::Clause::OMPC_if,
+ };
+
+ static OmpClauseSet allowedExclusiveClauses_OMPD_target_data {
+ };
+
+ static OmpClauseSet requiredClauses_OMPD_target_data {
+ llvm::omp::Clause::OMPC_map,
+ };
+
+ // Sets for target enter data
+
+ static OmpClauseSet allowedClauses_OMPD_target_enter_data {
+ llvm::omp::Clause::OMPC_depend,
+ };
+
+ static OmpClauseSet allowedOnceClauses_OMPD_target_enter_data {
+ llvm::omp::Clause::OMPC_if,
+ llvm::omp::Clause::OMPC_device,
+ llvm::omp::Clause::OMPC_nowait,
+ };
+
+ static OmpClauseSet allowedExclusiveClauses_OMPD_target_enter_data {
+ };
+
+ static OmpClauseSet requiredClauses_OMPD_target_enter_data {
+ llvm::omp::Clause::OMPC_map,
+ };
+
+ // Sets for target exit data
+
+ static OmpClauseSet allowedClauses_OMPD_target_exit_data {
+ llvm::omp::Clause::OMPC_depend,
+ };
+
+ static OmpClauseSet allowedOnceClauses_OMPD_target_exit_data {
+ llvm::omp::Clause::OMPC_device,
+ llvm::omp::Clause::OMPC_if,
+ llvm::omp::Clause::OMPC_nowait,
+ };
+
+ static OmpClauseSet allowedExclusiveClauses_OMPD_target_exit_data {
+ };
+
+ static OmpClauseSet requiredClauses_OMPD_target_exit_data {
+ llvm::omp::Clause::OMPC_map,
+ };
+
+ // Sets for target parallel
+
+ static OmpClauseSet allowedClauses_OMPD_target_parallel {
+ llvm::omp::Clause::OMPC_map,
+ llvm::omp::Clause::OMPC_nowait,
+ llvm::omp::Clause::OMPC_depend,
+ llvm::omp::Clause::OMPC_private,
+ llvm::omp::Clause::OMPC_firstprivate,
+ llvm::omp::Clause::OMPC_default,
+ llvm::omp::Clause::OMPC_shared,
+ llvm::omp::Clause::OMPC_reduction,
+ llvm::omp::Clause::OMPC_is_device_ptr,
+ llvm::omp::Clause::OMPC_allocate,
+ llvm::omp::Clause::OMPC_uses_allocators,
+ };
+
+ static OmpClauseSet allowedOnceClauses_OMPD_target_parallel {
+ llvm::omp::Clause::OMPC_defaultmap,
+ llvm::omp::Clause::OMPC_device,
+ llvm::omp::Clause::OMPC_if,
+ llvm::omp::Clause::OMPC_num_threads,
+ llvm::omp::Clause::OMPC_proc_bind,
+ };
+
+ static OmpClauseSet allowedExclusiveClauses_OMPD_target_parallel {
+ };
+
+ static OmpClauseSet requiredClauses_OMPD_target_parallel {
+ };
+
+ // Sets for target parallel do
+
+ static OmpClauseSet allowedClauses_OMPD_target_parallel_do {
+ llvm::omp::Clause::OMPC_map,
+ llvm::omp::Clause::OMPC_private,
+ llvm::omp::Clause::OMPC_firstprivate,
+ llvm::omp::Clause::OMPC_lastprivate,
+ llvm::omp::Clause::OMPC_depend,
+ llvm::omp::Clause::OMPC_shared,
+ llvm::omp::Clause::OMPC_reduction,
+ llvm::omp::Clause::OMPC_linear,
+ llvm::omp::Clause::OMPC_is_device_ptr,
+ llvm::omp::Clause::OMPC_allocator,
+ llvm::omp::Clause::OMPC_order,
+ llvm::omp::Clause::OMPC_uses_allocators,
+ llvm::omp::Clause::OMPC_default,
+ llvm::omp::Clause::OMPC_copyin,
+ };
+
+ static OmpClauseSet allowedOnceClauses_OMPD_target_parallel_do {
+ llvm::omp::Clause::OMPC_if,
+ llvm::omp::Clause::OMPC_num_threads,
+ llvm::omp::Clause::OMPC_proc_bind,
+ llvm::omp::Clause::OMPC_device,
+ llvm::omp::Clause::OMPC_defaultmap,
+ llvm::omp::Clause::OMPC_schedule,
+ llvm::omp::Clause::OMPC_collapse,
+ llvm::omp::Clause::OMPC_ordered,
+ llvm::omp::Clause::OMPC_nowait,
+ };
+
+ static OmpClauseSet allowedExclusiveClauses_OMPD_target_parallel_do {
+ };
+
+ static OmpClauseSet requiredClauses_OMPD_target_parallel_do {
+ };
+
+ // Sets for target parallel do simd
+
+ static OmpClauseSet allowedClauses_OMPD_target_parallel_do_simd {
+ llvm::omp::Clause::OMPC_if,
+ llvm::omp::Clause::OMPC_device,
+ llvm::omp::Clause::OMPC_map,
+ llvm::omp::Clause::OMPC_private,
+ llvm::omp::Clause::OMPC_firstprivate,
+ llvm::omp::Clause::OMPC_lastprivate,
+ llvm::omp::Clause::OMPC_nowait,
+ llvm::omp::Clause::OMPC_depend,
+ llvm::omp::Clause::OMPC_defaultmap,
+ llvm::omp::Clause::OMPC_num_threads,
+ llvm::omp::Clause::OMPC_default,
+ llvm::omp::Clause::OMPC_proc_bind,
+ llvm::omp::Clause::OMPC_shared,
+ llvm::omp::Clause::OMPC_reduction,
+ llvm::omp::Clause::OMPC_collapse,
+ llvm::omp::Clause::OMPC_schedule,
+ llvm::omp::Clause::OMPC_ordered,
+ llvm::omp::Clause::OMPC_linear,
+ llvm::omp::Clause::OMPC_safelen,
+ llvm::omp::Clause::OMPC_simdlen,
+ llvm::omp::Clause::OMPC_aligned,
+ llvm::omp::Clause::OMPC_is_device_ptr,
+ llvm::omp::Clause::OMPC_allocate,
+ llvm::omp::Clause::OMPC_nontemporal,
+ llvm::omp::Clause::OMPC_order,
+ llvm::omp::Clause::OMPC_uses_allocators,
+ };
+
+ static OmpClauseSet allowedOnceClauses_OMPD_target_parallel_do_simd {
+ };
+
+ static OmpClauseSet allowedExclusiveClauses_OMPD_target_parallel_do_simd {
+ };
+
+ static OmpClauseSet requiredClauses_OMPD_target_parallel_do_simd {
+ };
+
+ // Sets for target parallel for
+
+ static OmpClauseSet allowedClauses_OMPD_target_parallel_for {
+ llvm::omp::Clause::OMPC_if,
+ llvm::omp::Clause::OMPC_device,
+ llvm::omp::Clause::OMPC_map,
+ llvm::omp::Clause::OMPC_private,
+ llvm::omp::Clause::OMPC_firstprivate,
+ llvm::omp::Clause::OMPC_lastprivate,
+ llvm::omp::Clause::OMPC_nowait,
+ llvm::omp::Clause::OMPC_depend,
+ llvm::omp::Clause::OMPC_defaultmap,
+ llvm::omp::Clause::OMPC_num_threads,
+ llvm::omp::Clause::OMPC_default,
+ llvm::omp::Clause::OMPC_proc_bind,
+ llvm::omp::Clause::OMPC_shared,
+ llvm::omp::Clause::OMPC_reduction,
+ llvm::omp::Clause::OMPC_collapse,
+ llvm::omp::Clause::OMPC_schedule,
+ llvm::omp::Clause::OMPC_ordered,
+ llvm::omp::Clause::OMPC_linear,
+ llvm::omp::Clause::OMPC_is_device_ptr,
+ llvm::omp::Clause::OMPC_allocate,
+ llvm::omp::Clause::OMPC_order,
+ llvm::omp::Clause::OMPC_uses_allocators,
+ };
+
+ static OmpClauseSet allowedOnceClauses_OMPD_target_parallel_for {
+ };
+
+ static OmpClauseSet allowedExclusiveClauses_OMPD_target_parallel_for {
+ };
+
+ static OmpClauseSet requiredClauses_OMPD_target_parallel_for {
+ };
+
+ // Sets for target parallel for simd
+
+ static OmpClauseSet allowedClauses_OMPD_target_parallel_for_simd {
+ llvm::omp::Clause::OMPC_if,
+ llvm::omp::Clause::OMPC_device,
+ llvm::omp::Clause::OMPC_map,
+ llvm::omp::Clause::OMPC_private,
+ llvm::omp::Clause::OMPC_firstprivate,
+ llvm::omp::Clause::OMPC_lastprivate,
+ llvm::omp::Clause::OMPC_nowait,
+ llvm::omp::Clause::OMPC_depend,
+ llvm::omp::Clause::OMPC_defaultmap,
+ llvm::omp::Clause::OMPC_num_threads,
+ llvm::omp::Clause::OMPC_default,
+ llvm::omp::Clause::OMPC_proc_bind,
+ llvm::omp::Clause::OMPC_shared,
+ llvm::omp::Clause::OMPC_reduction,
+ llvm::omp::Clause::OMPC_collapse,
+ llvm::omp::Clause::OMPC_schedule,
+ llvm::omp::Clause::OMPC_ordered,
+ llvm::omp::Clause::OMPC_linear,
+ llvm::omp::Clause::OMPC_safelen,
+ llvm::omp::Clause::OMPC_simdlen,
+ llvm::omp::Clause::OMPC_aligned,
+ llvm::omp::Clause::OMPC_is_device_ptr,
+ llvm::omp::Clause::OMPC_allocate,
+ llvm::omp::Clause::OMPC_nontemporal,
+ llvm::omp::Clause::OMPC_order,
+ llvm::omp::Clause::OMPC_uses_allocators,
+ };
+
+ static OmpClauseSet allowedOnceClauses_OMPD_target_parallel_for_simd {
+ };
+
+ static OmpClauseSet allowedExclusiveClauses_OMPD_target_parallel_for_simd {
+ };
+
+ static OmpClauseSet requiredClauses_OMPD_target_parallel_for_simd {
+ };
+
+ // Sets for target simd
+
+ static OmpClauseSet allowedClauses_OMPD_target_simd {
+ llvm::omp::Clause::OMPC_aligned,
+ llvm::omp::Clause::OMPC_allocate,
+ llvm::omp::Clause::OMPC_depend,
+ llvm::omp::Clause::OMPC_firstprivate,
+ llvm::omp::Clause::OMPC_is_device_ptr,
+ llvm::omp::Clause::OMPC_lastprivate,
+ llvm::omp::Clause::OMPC_linear,
+ llvm::omp::Clause::OMPC_map,
+ llvm::omp::Clause::OMPC_nontemporal,
+ llvm::omp::Clause::OMPC_nowait,
+ llvm::omp::Clause::OMPC_order,
+ llvm::omp::Clause::OMPC_private,
+ llvm::omp::Clause::OMPC_reduction,
+ llvm::omp::Clause::OMPC_shared,
+ llvm::omp::Clause::OMPC_uses_allocators,
+ };
+
+ static OmpClauseSet allowedOnceClauses_OMPD_target_simd {
+ llvm::omp::Clause::OMPC_collapse,
+ llvm::omp::Clause::OMPC_safelen,
+ llvm::omp::Clause::OMPC_simdlen,
+ llvm::omp::Clause::OMPC_if,
+ llvm::omp::Clause::OMPC_num_threads,
+ llvm::omp::Clause::OMPC_proc_bind,
+ llvm::omp::Clause::OMPC_device,
+ llvm::omp::Clause::OMPC_defaultmap,
+ llvm::omp::Clause::OMPC_schedule,
+ };
+
+ static OmpClauseSet allowedExclusiveClauses_OMPD_target_simd {
+ };
+
+ static OmpClauseSet requiredClauses_OMPD_target_simd {
+ };
+
+ // Sets for target teams
+
+ static OmpClauseSet allowedClauses_OMPD_target_teams {
+ llvm::omp::Clause::OMPC_if,
+ llvm::omp::Clause::OMPC_map,
+ llvm::omp::Clause::OMPC_private,
+ llvm::omp::Clause::OMPC_depend,
+ llvm::omp::Clause::OMPC_firstprivate,
+ llvm::omp::Clause::OMPC_is_device_ptr,
+ llvm::omp::Clause::OMPC_reduction,
+ llvm::omp::Clause::OMPC_allocate,
+ llvm::omp::Clause::OMPC_uses_allocators,
+ llvm::omp::Clause::OMPC_shared,
+ };
+
+ static OmpClauseSet allowedOnceClauses_OMPD_target_teams {
+ llvm::omp::Clause::OMPC_device,
+ llvm::omp::Clause::OMPC_nowait,
+ llvm::omp::Clause::OMPC_defaultmap,
+ llvm::omp::Clause::OMPC_default,
+ llvm::omp::Clause::OMPC_num_teams,
+ llvm::omp::Clause::OMPC_thread_limit,
+ };
+
+ static OmpClauseSet allowedExclusiveClauses_OMPD_target_teams {
+ };
+
+ static OmpClauseSet requiredClauses_OMPD_target_teams {
+ };
+
+ // Sets for target teams distribute
+
+ static OmpClauseSet allowedClauses_OMPD_target_teams_distribute {
+ llvm::omp::Clause::OMPC_if,
+ llvm::omp::Clause::OMPC_map,
+ llvm::omp::Clause::OMPC_private,
+ llvm::omp::Clause::OMPC_depend,
+ llvm::omp::Clause::OMPC_firstprivate,
+ llvm::omp::Clause::OMPC_is_device_ptr,
+ llvm::omp::Clause::OMPC_reduction,
+ llvm::omp::Clause::OMPC_allocate,
+ llvm::omp::Clause::OMPC_uses_allocators,
+ llvm::omp::Clause::OMPC_shared,
+ llvm::omp::Clause::OMPC_lastprivate,
+ };
+
+ static OmpClauseSet allowedOnceClauses_OMPD_target_teams_distribute {
+ llvm::omp::Clause::OMPC_device,
+ llvm::omp::Clause::OMPC_nowait,
+ llvm::omp::Clause::OMPC_defaultmap,
+ llvm::omp::Clause::OMPC_default,
+ llvm::omp::Clause::OMPC_num_teams,
+ llvm::omp::Clause::OMPC_thread_limit,
+ llvm::omp::Clause::OMPC_collapse,
+ llvm::omp::Clause::OMPC_dist_schedule,
+ };
+
+ static OmpClauseSet allowedExclusiveClauses_OMPD_target_teams_distribute {
+ };
+
+ static OmpClauseSet requiredClauses_OMPD_target_teams_distribute {
+ };
+
+ // Sets for target teams distribute parallel do
+
+ static OmpClauseSet allowedClauses_OMPD_target_teams_distribute_parallel_do {
+ llvm::omp::Clause::OMPC_if,
+ llvm::omp::Clause::OMPC_map,
+ llvm::omp::Clause::OMPC_private,
+ llvm::omp::Clause::OMPC_depend,
+ llvm::omp::Clause::OMPC_firstprivate,
+ llvm::omp::Clause::OMPC_is_device_ptr,
+ llvm::omp::Clause::OMPC_reduction,
+ llvm::omp::Clause::OMPC_allocate,
+ llvm::omp::Clause::OMPC_uses_allocators,
+ llvm::omp::Clause::OMPC_shared,
+ llvm::omp::Clause::OMPC_lastprivate,
+ llvm::omp::Clause::OMPC_copyin,
+ llvm::omp::Clause::OMPC_linear,
+ llvm::omp::Clause::OMPC_ordered,
+ llvm::omp::Clause::OMPC_order,
+ };
+
+ static OmpClauseSet allowedOnceClauses_OMPD_target_teams_distribute_parallel_do {
+ llvm::omp::Clause::OMPC_device,
+ llvm::omp::Clause::OMPC_defaultmap,
+ llvm::omp::Clause::OMPC_nowait,
+ llvm::omp::Clause::OMPC_default,
+ llvm::omp::Clause::OMPC_num_teams,
+ llvm::omp::Clause::OMPC_thread_limit,
+ llvm::omp::Clause::OMPC_collapse,
+ llvm::omp::Clause::OMPC_dist_schedule,
+ llvm::omp::Clause::OMPC_num_threads,
+ llvm::omp::Clause::OMPC_proc_bind,
+ llvm::omp::Clause::OMPC_schedule,
+ };
+
+ static OmpClauseSet allowedExclusiveClauses_OMPD_target_teams_distribute_parallel_do {
+ };
+
+ static OmpClauseSet requiredClauses_OMPD_target_teams_distribute_parallel_do {
+ };
+
+ // Sets for target teams distribute parallel do simd
+
+ static OmpClauseSet allowedClauses_OMPD_target_teams_distribute_parallel_do_simd {
+ llvm::omp::Clause::OMPC_map,
+ llvm::omp::Clause::OMPC_private,
+ llvm::omp::Clause::OMPC_depend,
+ llvm::omp::Clause::OMPC_firstprivate,
+ llvm::omp::Clause::OMPC_is_device_ptr,
+ llvm::omp::Clause::OMPC_reduction,
+ llvm::omp::Clause::OMPC_allocate,
+ llvm::omp::Clause::OMPC_uses_allocators,
+ llvm::omp::Clause::OMPC_shared,
+ llvm::omp::Clause::OMPC_lastprivate,
+ llvm::omp::Clause::OMPC_copyin,
+ llvm::omp::Clause::OMPC_linear,
+ llvm::omp::Clause::OMPC_ordered,
+ llvm::omp::Clause::OMPC_order,
+ llvm::omp::Clause::OMPC_aligned,
+ llvm::omp::Clause::OMPC_nontemporal,
+ };
+
+ static OmpClauseSet allowedOnceClauses_OMPD_target_teams_distribute_parallel_do_simd {
+ llvm::omp::Clause::OMPC_if,
+ llvm::omp::Clause::OMPC_device,
+ llvm::omp::Clause::OMPC_nowait,
+ llvm::omp::Clause::OMPC_defaultmap,
+ llvm::omp::Clause::OMPC_default,
+ llvm::omp::Clause::OMPC_num_teams,
+ llvm::omp::Clause::OMPC_thread_limit,
+ llvm::omp::Clause::OMPC_collapse,
+ llvm::omp::Clause::OMPC_dist_schedule,
+ llvm::omp::Clause::OMPC_num_threads,
+ llvm::omp::Clause::OMPC_proc_bind,
+ llvm::omp::Clause::OMPC_schedule,
+ llvm::omp::Clause::OMPC_safelen,
+ llvm::omp::Clause::OMPC_simdlen,
+ };
+
+ static OmpClauseSet allowedExclusiveClauses_OMPD_target_teams_distribute_parallel_do_simd {
+ };
+
+ static OmpClauseSet requiredClauses_OMPD_target_teams_distribute_parallel_do_simd {
+ };
+
+ // Sets for target teams distribute parallel for
+
+ static OmpClauseSet allowedClauses_OMPD_target_teams_distribute_parallel_for {
+ llvm::omp::Clause::OMPC_if,
+ llvm::omp::Clause::OMPC_device,
+ llvm::omp::Clause::OMPC_map,
+ llvm::omp::Clause::OMPC_private,
+ llvm::omp::Clause::OMPC_nowait,
+ llvm::omp::Clause::OMPC_depend,
+ llvm::omp::Clause::OMPC_defaultmap,
+ llvm::omp::Clause::OMPC_firstprivate,
+ llvm::omp::Clause::OMPC_is_device_ptr,
+ llvm::omp::Clause::OMPC_default,
+ llvm::omp::Clause::OMPC_shared,
+ llvm::omp::Clause::OMPC_reduction,
+ llvm::omp::Clause::OMPC_num_teams,
+ llvm::omp::Clause::OMPC_thread_limit,
+ llvm::omp::Clause::OMPC_lastprivate,
+ llvm::omp::Clause::OMPC_collapse,
+ llvm::omp::Clause::OMPC_dist_schedule,
+ llvm::omp::Clause::OMPC_num_threads,
+ llvm::omp::Clause::OMPC_proc_bind,
+ llvm::omp::Clause::OMPC_schedule,
+ llvm::omp::Clause::OMPC_allocate,
+ llvm::omp::Clause::OMPC_order,
+ llvm::omp::Clause::OMPC_uses_allocators,
+ };
+
+ static OmpClauseSet allowedOnceClauses_OMPD_target_teams_distribute_parallel_for {
+ };
+
+ static OmpClauseSet allowedExclusiveClauses_OMPD_target_teams_distribute_parallel_for {
+ };
+
+ static OmpClauseSet requiredClauses_OMPD_target_teams_distribute_parallel_for {
+ };
+
+ // Sets for target teams distribute parallel for simd
+
+ static OmpClauseSet allowedClauses_OMPD_target_teams_distribute_parallel_for_simd {
+ llvm::omp::Clause::OMPC_if,
+ llvm::omp::Clause::OMPC_device,
+ llvm::omp::Clause::OMPC_map,
+ llvm::omp::Clause::OMPC_private,
+ llvm::omp::Clause::OMPC_nowait,
+ llvm::omp::Clause::OMPC_depend,
+ llvm::omp::Clause::OMPC_defaultmap,
+ llvm::omp::Clause::OMPC_firstprivate,
+ llvm::omp::Clause::OMPC_is_device_ptr,
+ llvm::omp::Clause::OMPC_default,
+ llvm::omp::Clause::OMPC_shared,
+ llvm::omp::Clause::OMPC_reduction,
+ llvm::omp::Clause::OMPC_num_teams,
+ llvm::omp::Clause::OMPC_thread_limit,
+ llvm::omp::Clause::OMPC_lastprivate,
+ llvm::omp::Clause::OMPC_collapse,
+ llvm::omp::Clause::OMPC_dist_schedule,
+ llvm::omp::Clause::OMPC_num_threads,
+ llvm::omp::Clause::OMPC_proc_bind,
+ llvm::omp::Clause::OMPC_schedule,
+ llvm::omp::Clause::OMPC_linear,
+ llvm::omp::Clause::OMPC_aligned,
+ llvm::omp::Clause::OMPC_safelen,
+ llvm::omp::Clause::OMPC_simdlen,
+ llvm::omp::Clause::OMPC_allocate,
+ llvm::omp::Clause::OMPC_nontemporal,
+ llvm::omp::Clause::OMPC_order,
+ llvm::omp::Clause::OMPC_uses_allocators,
+ };
+
+ static OmpClauseSet allowedOnceClauses_OMPD_target_teams_distribute_parallel_for_simd {
+ };
+
+ static OmpClauseSet allowedExclusiveClauses_OMPD_target_teams_distribute_parallel_for_simd {
+ };
+
+ static OmpClauseSet requiredClauses_OMPD_target_teams_distribute_parallel_for_simd {
+ };
+
+ // Sets for target teams distribute simd
+
+ static OmpClauseSet allowedClauses_OMPD_target_teams_distribute_simd {
+ llvm::omp::Clause::OMPC_aligned,
+ llvm::omp::Clause::OMPC_allocate,
+ llvm::omp::Clause::OMPC_depend,
+ llvm::omp::Clause::OMPC_firstprivate,
+ llvm::omp::Clause::OMPC_if,
+ llvm::omp::Clause::OMPC_is_device_ptr,
+ llvm::omp::Clause::OMPC_lastprivate,
+ llvm::omp::Clause::OMPC_linear,
+ llvm::omp::Clause::OMPC_map,
+ llvm::omp::Clause::OMPC_nontemporal,
+ llvm::omp::Clause::OMPC_order,
+ llvm::omp::Clause::OMPC_private,
+ llvm::omp::Clause::OMPC_reduction,
+ llvm::omp::Clause::OMPC_shared,
+ llvm::omp::Clause::OMPC_uses_allocators,
+ };
+
+ static OmpClauseSet allowedOnceClauses_OMPD_target_teams_distribute_simd {
+ llvm::omp::Clause::OMPC_device,
+ llvm::omp::Clause::OMPC_defaultmap,
+ llvm::omp::Clause::OMPC_nowait,
+ llvm::omp::Clause::OMPC_num_teams,
+ llvm::omp::Clause::OMPC_thread_limit,
+ llvm::omp::Clause::OMPC_collapse,
+ llvm::omp::Clause::OMPC_dist_schedule,
+ llvm::omp::Clause::OMPC_safelen,
+ llvm::omp::Clause::OMPC_simdlen,
+ };
+
+ static OmpClauseSet allowedExclusiveClauses_OMPD_target_teams_distribute_simd {
+ };
+
+ static OmpClauseSet requiredClauses_OMPD_target_teams_distribute_simd {
+ };
+
+ // Sets for target update
+
+ static OmpClauseSet allowedClauses_OMPD_target_update {
+ llvm::omp::Clause::OMPC_if,
+ llvm::omp::Clause::OMPC_device,
+ llvm::omp::Clause::OMPC_to,
+ llvm::omp::Clause::OMPC_from,
+ llvm::omp::Clause::OMPC_nowait,
+ llvm::omp::Clause::OMPC_depend,
+ };
+
+ static OmpClauseSet allowedOnceClauses_OMPD_target_update {
+ };
+
+ static OmpClauseSet allowedExclusiveClauses_OMPD_target_update {
+ };
+
+ static OmpClauseSet requiredClauses_OMPD_target_update {
+ };
+
+ // Sets for task
+
+ static OmpClauseSet allowedClauses_OMPD_task {
+ llvm::omp::Clause::OMPC_private,
+ llvm::omp::Clause::OMPC_firstprivate,
+ llvm::omp::Clause::OMPC_shared,
+ llvm::omp::Clause::OMPC_untied,
+ llvm::omp::Clause::OMPC_mergeable,
+ llvm::omp::Clause::OMPC_depend,
+ llvm::omp::Clause::OMPC_in_reduction,
+ llvm::omp::Clause::OMPC_allocate,
+ llvm::omp::Clause::OMPC_detach,
+ llvm::omp::Clause::OMPC_affinity,
+ };
+
+ static OmpClauseSet allowedOnceClauses_OMPD_task {
+ llvm::omp::Clause::OMPC_default,
+ llvm::omp::Clause::OMPC_if,
+ llvm::omp::Clause::OMPC_final,
+ llvm::omp::Clause::OMPC_priority,
+ };
+
+ static OmpClauseSet allowedExclusiveClauses_OMPD_task {
+ };
+
+ static OmpClauseSet requiredClauses_OMPD_task {
+ };
+
+ // Sets for taskgroup
+
+ static OmpClauseSet allowedClauses_OMPD_taskgroup {
+ llvm::omp::Clause::OMPC_task_reduction,
+ llvm::omp::Clause::OMPC_allocate,
+ };
+
+ static OmpClauseSet allowedOnceClauses_OMPD_taskgroup {
+ };
+
+ static OmpClauseSet allowedExclusiveClauses_OMPD_taskgroup {
+ };
+
+ static OmpClauseSet requiredClauses_OMPD_taskgroup {
+ };
+
+ // Sets for taskloop
+
+ static OmpClauseSet allowedClauses_OMPD_taskloop {
+ llvm::omp::Clause::OMPC_shared,
+ llvm::omp::Clause::OMPC_private,
+ llvm::omp::Clause::OMPC_firstprivate,
+ llvm::omp::Clause::OMPC_lastprivate,
+ llvm::omp::Clause::OMPC_untied,
+ llvm::omp::Clause::OMPC_mergeable,
+ llvm::omp::Clause::OMPC_nogroup,
+ llvm::omp::Clause::OMPC_reduction,
+ llvm::omp::Clause::OMPC_in_reduction,
+ llvm::omp::Clause::OMPC_allocate,
+ };
+
+ static OmpClauseSet allowedOnceClauses_OMPD_taskloop {
+ llvm::omp::Clause::OMPC_default,
+ llvm::omp::Clause::OMPC_if,
+ llvm::omp::Clause::OMPC_collapse,
+ llvm::omp::Clause::OMPC_final,
+ llvm::omp::Clause::OMPC_priority,
+ };
+
+ static OmpClauseSet allowedExclusiveClauses_OMPD_taskloop {
+ llvm::omp::Clause::OMPC_grainsize,
+ llvm::omp::Clause::OMPC_num_tasks,
+ };
+
+ static OmpClauseSet requiredClauses_OMPD_taskloop {
+ };
+
+ // Sets for taskloop simd
+
+ static OmpClauseSet allowedClauses_OMPD_taskloop_simd {
+ llvm::omp::Clause::OMPC_aligned,
+ llvm::omp::Clause::OMPC_allocate,
+ llvm::omp::Clause::OMPC_default,
+ llvm::omp::Clause::OMPC_firstprivate,
+ llvm::omp::Clause::OMPC_in_reduction,
+ llvm::omp::Clause::OMPC_lastprivate,
+ llvm::omp::Clause::OMPC_linear,
+ llvm::omp::Clause::OMPC_mergeable,
+ llvm::omp::Clause::OMPC_nogroup,
+ llvm::omp::Clause::OMPC_nontemporal,
+ llvm::omp::Clause::OMPC_order,
+ llvm::omp::Clause::OMPC_private,
+ llvm::omp::Clause::OMPC_reduction,
+ llvm::omp::Clause::OMPC_shared,
+ llvm::omp::Clause::OMPC_untied,
+ };
+
+ static OmpClauseSet allowedOnceClauses_OMPD_taskloop_simd {
+ llvm::omp::Clause::OMPC_if,
+ llvm::omp::Clause::OMPC_collapse,
+ llvm::omp::Clause::OMPC_safelen,
+ llvm::omp::Clause::OMPC_simdlen,
+ llvm::omp::Clause::OMPC_final,
+ llvm::omp::Clause::OMPC_priority,
+ };
+
+ static OmpClauseSet allowedExclusiveClauses_OMPD_taskloop_simd {
+ llvm::omp::Clause::OMPC_grainsize,
+ llvm::omp::Clause::OMPC_num_tasks,
+ };
+
+ static OmpClauseSet requiredClauses_OMPD_taskloop_simd {
+ };
+
+ // Sets for taskwait
+
+ static OmpClauseSet allowedClauses_OMPD_taskwait {
+ llvm::omp::Clause::OMPC_depend,
+ };
+
+ static OmpClauseSet allowedOnceClauses_OMPD_taskwait {
+ };
+
+ static OmpClauseSet allowedExclusiveClauses_OMPD_taskwait {
+ };
+
+ static OmpClauseSet requiredClauses_OMPD_taskwait {
+ };
+
+ // Sets for taskyield
+
+ static OmpClauseSet allowedClauses_OMPD_taskyield {
+ };
+
+ static OmpClauseSet allowedOnceClauses_OMPD_taskyield {
+ };
+
+ static OmpClauseSet allowedExclusiveClauses_OMPD_taskyield {
+ };
+
+ static OmpClauseSet requiredClauses_OMPD_taskyield {
+ };
+
+ // Sets for teams
+
+ static OmpClauseSet allowedClauses_OMPD_teams {
+ llvm::omp::Clause::OMPC_private,
+ llvm::omp::Clause::OMPC_firstprivate,
+ llvm::omp::Clause::OMPC_shared,
+ llvm::omp::Clause::OMPC_reduction,
+ llvm::omp::Clause::OMPC_allocate,
+ };
+
+ static OmpClauseSet allowedOnceClauses_OMPD_teams {
+ llvm::omp::Clause::OMPC_default,
+ llvm::omp::Clause::OMPC_num_teams,
+ llvm::omp::Clause::OMPC_thread_limit,
+ };
+
+ static OmpClauseSet allowedExclusiveClauses_OMPD_teams {
+ };
+
+ static OmpClauseSet requiredClauses_OMPD_teams {
+ };
+
+ // Sets for teams distribute
+
+ static OmpClauseSet allowedClauses_OMPD_teams_distribute {
+ llvm::omp::Clause::OMPC_default,
+ llvm::omp::Clause::OMPC_private,
+ llvm::omp::Clause::OMPC_firstprivate,
+ llvm::omp::Clause::OMPC_shared,
+ llvm::omp::Clause::OMPC_reduction,
+ llvm::omp::Clause::OMPC_num_teams,
+ llvm::omp::Clause::OMPC_thread_limit,
+ llvm::omp::Clause::OMPC_lastprivate,
+ llvm::omp::Clause::OMPC_collapse,
+ llvm::omp::Clause::OMPC_dist_schedule,
+ llvm::omp::Clause::OMPC_allocate,
+ };
+
+ static OmpClauseSet allowedOnceClauses_OMPD_teams_distribute {
+ };
+
+ static OmpClauseSet allowedExclusiveClauses_OMPD_teams_distribute {
+ };
+
+ static OmpClauseSet requiredClauses_OMPD_teams_distribute {
+ };
+
+ // Sets for teams distribute parallel do
+
+ static OmpClauseSet allowedClauses_OMPD_teams_distribute_parallel_do {
+ llvm::omp::Clause::OMPC_private,
+ llvm::omp::Clause::OMPC_firstprivate,
+ llvm::omp::Clause::OMPC_lastprivate,
+ llvm::omp::Clause::OMPC_shared,
+ llvm::omp::Clause::OMPC_reduction,
+ llvm::omp::Clause::OMPC_allocate,
+ llvm::omp::Clause::OMPC_copyin,
+ llvm::omp::Clause::OMPC_linear,
+ };
+
+ static OmpClauseSet allowedOnceClauses_OMPD_teams_distribute_parallel_do {
+ llvm::omp::Clause::OMPC_num_teams,
+ llvm::omp::Clause::OMPC_thread_limit,
+ llvm::omp::Clause::OMPC_default,
+ llvm::omp::Clause::OMPC_collapse,
+ llvm::omp::Clause::OMPC_dist_schedule,
+ llvm::omp::Clause::OMPC_ordered,
+ llvm::omp::Clause::OMPC_order,
+ llvm::omp::Clause::OMPC_if,
+ llvm::omp::Clause::OMPC_num_threads,
+ llvm::omp::Clause::OMPC_proc_bind,
+ llvm::omp::Clause::OMPC_schedule,
+ };
+
+ static OmpClauseSet allowedExclusiveClauses_OMPD_teams_distribute_parallel_do {
+ };
+
+ static OmpClauseSet requiredClauses_OMPD_teams_distribute_parallel_do {
+ };
+
+ // Sets for teams distribute parallel do simd
+
+ static OmpClauseSet allowedClauses_OMPD_teams_distribute_parallel_do_simd {
+ llvm::omp::Clause::OMPC_private,
+ llvm::omp::Clause::OMPC_firstprivate,
+ llvm::omp::Clause::OMPC_lastprivate,
+ llvm::omp::Clause::OMPC_allocate,
+ llvm::omp::Clause::OMPC_shared,
+ llvm::omp::Clause::OMPC_reduction,
+ llvm::omp::Clause::OMPC_linear,
+ llvm::omp::Clause::OMPC_order,
+ llvm::omp::Clause::OMPC_aligned,
+ llvm::omp::Clause::OMPC_nontemporal,
+ };
+
+ static OmpClauseSet allowedOnceClauses_OMPD_teams_distribute_parallel_do_simd {
+ llvm::omp::Clause::OMPC_default,
+ llvm::omp::Clause::OMPC_num_teams,
+ llvm::omp::Clause::OMPC_thread_limit,
+ llvm::omp::Clause::OMPC_collapse,
+ llvm::omp::Clause::OMPC_dist_schedule,
+ llvm::omp::Clause::OMPC_num_threads,
+ llvm::omp::Clause::OMPC_proc_bind,
+ llvm::omp::Clause::OMPC_schedule,
+ llvm::omp::Clause::OMPC_safelen,
+ llvm::omp::Clause::OMPC_simdlen,
+ llvm::omp::Clause::OMPC_if,
+ };
+
+ static OmpClauseSet allowedExclusiveClauses_OMPD_teams_distribute_parallel_do_simd {
+ };
+
+ static OmpClauseSet requiredClauses_OMPD_teams_distribute_parallel_do_simd {
+ };
+
+ // Sets for teams distribute parallel for
+
+ static OmpClauseSet allowedClauses_OMPD_teams_distribute_parallel_for {
+ llvm::omp::Clause::OMPC_firstprivate,
+ llvm::omp::Clause::OMPC_lastprivate,
+ llvm::omp::Clause::OMPC_collapse,
+ llvm::omp::Clause::OMPC_dist_schedule,
+ llvm::omp::Clause::OMPC_if,
+ llvm::omp::Clause::OMPC_num_threads,
+ llvm::omp::Clause::OMPC_default,
+ llvm::omp::Clause::OMPC_proc_bind,
+ llvm::omp::Clause::OMPC_private,
+ llvm::omp::Clause::OMPC_shared,
+ llvm::omp::Clause::OMPC_reduction,
+ llvm::omp::Clause::OMPC_schedule,
+ llvm::omp::Clause::OMPC_num_teams,
+ llvm::omp::Clause::OMPC_thread_limit,
+ llvm::omp::Clause::OMPC_copyin,
+ llvm::omp::Clause::OMPC_allocate,
+ llvm::omp::Clause::OMPC_order,
+ };
+
+ static OmpClauseSet allowedOnceClauses_OMPD_teams_distribute_parallel_for {
+ };
+
+ static OmpClauseSet allowedExclusiveClauses_OMPD_teams_distribute_parallel_for {
+ };
+
+ static OmpClauseSet requiredClauses_OMPD_teams_distribute_parallel_for {
+ };
+
+ // Sets for teams distribute parallel for simd
+
+ static OmpClauseSet allowedClauses_OMPD_teams_distribute_parallel_for_simd {
+ llvm::omp::Clause::OMPC_firstprivate,
+ llvm::omp::Clause::OMPC_lastprivate,
+ llvm::omp::Clause::OMPC_collapse,
+ llvm::omp::Clause::OMPC_dist_schedule,
+ llvm::omp::Clause::OMPC_if,
+ llvm::omp::Clause::OMPC_num_threads,
+ llvm::omp::Clause::OMPC_default,
+ llvm::omp::Clause::OMPC_proc_bind,
+ llvm::omp::Clause::OMPC_private,
+ llvm::omp::Clause::OMPC_shared,
+ llvm::omp::Clause::OMPC_reduction,
+ llvm::omp::Clause::OMPC_schedule,
+ llvm::omp::Clause::OMPC_linear,
+ llvm::omp::Clause::OMPC_aligned,
+ llvm::omp::Clause::OMPC_safelen,
+ llvm::omp::Clause::OMPC_simdlen,
+ llvm::omp::Clause::OMPC_num_teams,
+ llvm::omp::Clause::OMPC_thread_limit,
+ llvm::omp::Clause::OMPC_allocate,
+ llvm::omp::Clause::OMPC_nontemporal,
+ llvm::omp::Clause::OMPC_order,
+ };
+
+ static OmpClauseSet allowedOnceClauses_OMPD_teams_distribute_parallel_for_simd {
+ };
+
+ static OmpClauseSet allowedExclusiveClauses_OMPD_teams_distribute_parallel_for_simd {
+ };
+
+ static OmpClauseSet requiredClauses_OMPD_teams_distribute_parallel_for_simd {
+ };
+
+ // Sets for teams distribute simd
+
+ static OmpClauseSet allowedClauses_OMPD_teams_distribute_simd {
+ llvm::omp::Clause::OMPC_aligned,
+ llvm::omp::Clause::OMPC_allocate,
+ llvm::omp::Clause::OMPC_firstprivate,
+ llvm::omp::Clause::OMPC_lastprivate,
+ llvm::omp::Clause::OMPC_linear,
+ llvm::omp::Clause::OMPC_nontemporal,
+ llvm::omp::Clause::OMPC_order,
+ llvm::omp::Clause::OMPC_private,
+ llvm::omp::Clause::OMPC_reduction,
+ llvm::omp::Clause::OMPC_shared,
+ };
+
+ static OmpClauseSet allowedOnceClauses_OMPD_teams_distribute_simd {
+ llvm::omp::Clause::OMPC_collapse,
+ llvm::omp::Clause::OMPC_default,
+ llvm::omp::Clause::OMPC_dist_schedule,
+ llvm::omp::Clause::OMPC_if,
+ llvm::omp::Clause::OMPC_num_teams,
+ llvm::omp::Clause::OMPC_safelen,
+ llvm::omp::Clause::OMPC_simdlen,
+ llvm::omp::Clause::OMPC_thread_limit,
+ };
+
+ static OmpClauseSet allowedExclusiveClauses_OMPD_teams_distribute_simd {
+ };
+
+ static OmpClauseSet requiredClauses_OMPD_teams_distribute_simd {
+ };
+
+ // Sets for threadprivate
+
+ static OmpClauseSet allowedClauses_OMPD_threadprivate {
+ };
+
+ static OmpClauseSet allowedOnceClauses_OMPD_threadprivate {
+ };
+
+ static OmpClauseSet allowedExclusiveClauses_OMPD_threadprivate {
+ };
+
+ static OmpClauseSet requiredClauses_OMPD_threadprivate {
+ };
+
+ // Sets for unknown
+
+ static OmpClauseSet allowedClauses_OMPD_unknown {
+ };
+
+ static OmpClauseSet allowedOnceClauses_OMPD_unknown {
+ };
+
+ static OmpClauseSet allowedExclusiveClauses_OMPD_unknown {
+ };
+
+ static OmpClauseSet requiredClauses_OMPD_unknown {
+ };
+
+ // Sets for workshare
+
+ static OmpClauseSet allowedClauses_OMPD_workshare {
+ };
+
+ static OmpClauseSet allowedOnceClauses_OMPD_workshare {
+ };
+
+ static OmpClauseSet allowedExclusiveClauses_OMPD_workshare {
+ };
+
+ static OmpClauseSet requiredClauses_OMPD_workshare {
+ };
+} // namespace omp
+} // namespace llvm
+
+#endif // GEN_FLANG_DIRECTIVE_CLAUSE_SETS
+
+#ifdef GEN_FLANG_DIRECTIVE_CLAUSE_MAP
+#undef GEN_FLANG_DIRECTIVE_CLAUSE_MAP
+
+{
+ {llvm::omp::Directive::OMPD_allocate,
+ {
+ llvm::omp::allowedClauses_OMPD_allocate,
+ llvm::omp::allowedOnceClauses_OMPD_allocate,
+ llvm::omp::allowedExclusiveClauses_OMPD_allocate,
+ llvm::omp::requiredClauses_OMPD_allocate,
+ }
+ },
+ {llvm::omp::Directive::OMPD_assumes,
+ {
+ llvm::omp::allowedClauses_OMPD_assumes,
+ llvm::omp::allowedOnceClauses_OMPD_assumes,
+ llvm::omp::allowedExclusiveClauses_OMPD_assumes,
+ llvm::omp::requiredClauses_OMPD_assumes,
+ }
+ },
+ {llvm::omp::Directive::OMPD_atomic,
+ {
+ llvm::omp::allowedClauses_OMPD_atomic,
+ llvm::omp::allowedOnceClauses_OMPD_atomic,
+ llvm::omp::allowedExclusiveClauses_OMPD_atomic,
+ llvm::omp::requiredClauses_OMPD_atomic,
+ }
+ },
+ {llvm::omp::Directive::OMPD_barrier,
+ {
+ llvm::omp::allowedClauses_OMPD_barrier,
+ llvm::omp::allowedOnceClauses_OMPD_barrier,
+ llvm::omp::allowedExclusiveClauses_OMPD_barrier,
+ llvm::omp::requiredClauses_OMPD_barrier,
+ }
+ },
+ {llvm::omp::Directive::OMPD_begin_assumes,
+ {
+ llvm::omp::allowedClauses_OMPD_begin_assumes,
+ llvm::omp::allowedOnceClauses_OMPD_begin_assumes,
+ llvm::omp::allowedExclusiveClauses_OMPD_begin_assumes,
+ llvm::omp::requiredClauses_OMPD_begin_assumes,
+ }
+ },
+ {llvm::omp::Directive::OMPD_begin_declare_variant,
+ {
+ llvm::omp::allowedClauses_OMPD_begin_declare_variant,
+ llvm::omp::allowedOnceClauses_OMPD_begin_declare_variant,
+ llvm::omp::allowedExclusiveClauses_OMPD_begin_declare_variant,
+ llvm::omp::requiredClauses_OMPD_begin_declare_variant,
+ }
+ },
+ {llvm::omp::Directive::OMPD_cancel,
+ {
+ llvm::omp::allowedClauses_OMPD_cancel,
+ llvm::omp::allowedOnceClauses_OMPD_cancel,
+ llvm::omp::allowedExclusiveClauses_OMPD_cancel,
+ llvm::omp::requiredClauses_OMPD_cancel,
+ }
+ },
+ {llvm::omp::Directive::OMPD_cancellation_point,
+ {
+ llvm::omp::allowedClauses_OMPD_cancellation_point,
+ llvm::omp::allowedOnceClauses_OMPD_cancellation_point,
+ llvm::omp::allowedExclusiveClauses_OMPD_cancellation_point,
+ llvm::omp::requiredClauses_OMPD_cancellation_point,
+ }
+ },
+ {llvm::omp::Directive::OMPD_critical,
+ {
+ llvm::omp::allowedClauses_OMPD_critical,
+ llvm::omp::allowedOnceClauses_OMPD_critical,
+ llvm::omp::allowedExclusiveClauses_OMPD_critical,
+ llvm::omp::requiredClauses_OMPD_critical,
+ }
+ },
+ {llvm::omp::Directive::OMPD_declare_mapper,
+ {
+ llvm::omp::allowedClauses_OMPD_declare_mapper,
+ llvm::omp::allowedOnceClauses_OMPD_declare_mapper,
+ llvm::omp::allowedExclusiveClauses_OMPD_declare_mapper,
+ llvm::omp::requiredClauses_OMPD_declare_mapper,
+ }
+ },
+ {llvm::omp::Directive::OMPD_declare_reduction,
+ {
+ llvm::omp::allowedClauses_OMPD_declare_reduction,
+ llvm::omp::allowedOnceClauses_OMPD_declare_reduction,
+ llvm::omp::allowedExclusiveClauses_OMPD_declare_reduction,
+ llvm::omp::requiredClauses_OMPD_declare_reduction,
+ }
+ },
+ {llvm::omp::Directive::OMPD_declare_simd,
+ {
+ llvm::omp::allowedClauses_OMPD_declare_simd,
+ llvm::omp::allowedOnceClauses_OMPD_declare_simd,
+ llvm::omp::allowedExclusiveClauses_OMPD_declare_simd,
+ llvm::omp::requiredClauses_OMPD_declare_simd,
+ }
+ },
+ {llvm::omp::Directive::OMPD_declare_target,
+ {
+ llvm::omp::allowedClauses_OMPD_declare_target,
+ llvm::omp::allowedOnceClauses_OMPD_declare_target,
+ llvm::omp::allowedExclusiveClauses_OMPD_declare_target,
+ llvm::omp::requiredClauses_OMPD_declare_target,
+ }
+ },
+ {llvm::omp::Directive::OMPD_declare_variant,
+ {
+ llvm::omp::allowedClauses_OMPD_declare_variant,
+ llvm::omp::allowedOnceClauses_OMPD_declare_variant,
+ llvm::omp::allowedExclusiveClauses_OMPD_declare_variant,
+ llvm::omp::requiredClauses_OMPD_declare_variant,
+ }
+ },
+ {llvm::omp::Directive::OMPD_depobj,
+ {
+ llvm::omp::allowedClauses_OMPD_depobj,
+ llvm::omp::allowedOnceClauses_OMPD_depobj,
+ llvm::omp::allowedExclusiveClauses_OMPD_depobj,
+ llvm::omp::requiredClauses_OMPD_depobj,
+ }
+ },
+ {llvm::omp::Directive::OMPD_distribute,
+ {
+ llvm::omp::allowedClauses_OMPD_distribute,
+ llvm::omp::allowedOnceClauses_OMPD_distribute,
+ llvm::omp::allowedExclusiveClauses_OMPD_distribute,
+ llvm::omp::requiredClauses_OMPD_distribute,
+ }
+ },
+ {llvm::omp::Directive::OMPD_distribute_parallel_do,
+ {
+ llvm::omp::allowedClauses_OMPD_distribute_parallel_do,
+ llvm::omp::allowedOnceClauses_OMPD_distribute_parallel_do,
+ llvm::omp::allowedExclusiveClauses_OMPD_distribute_parallel_do,
+ llvm::omp::requiredClauses_OMPD_distribute_parallel_do,
+ }
+ },
+ {llvm::omp::Directive::OMPD_distribute_parallel_do_simd,
+ {
+ llvm::omp::allowedClauses_OMPD_distribute_parallel_do_simd,
+ llvm::omp::allowedOnceClauses_OMPD_distribute_parallel_do_simd,
+ llvm::omp::allowedExclusiveClauses_OMPD_distribute_parallel_do_simd,
+ llvm::omp::requiredClauses_OMPD_distribute_parallel_do_simd,
+ }
+ },
+ {llvm::omp::Directive::OMPD_distribute_parallel_for,
+ {
+ llvm::omp::allowedClauses_OMPD_distribute_parallel_for,
+ llvm::omp::allowedOnceClauses_OMPD_distribute_parallel_for,
+ llvm::omp::allowedExclusiveClauses_OMPD_distribute_parallel_for,
+ llvm::omp::requiredClauses_OMPD_distribute_parallel_for,
+ }
+ },
+ {llvm::omp::Directive::OMPD_distribute_parallel_for_simd,
+ {
+ llvm::omp::allowedClauses_OMPD_distribute_parallel_for_simd,
+ llvm::omp::allowedOnceClauses_OMPD_distribute_parallel_for_simd,
+ llvm::omp::allowedExclusiveClauses_OMPD_distribute_parallel_for_simd,
+ llvm::omp::requiredClauses_OMPD_distribute_parallel_for_simd,
+ }
+ },
+ {llvm::omp::Directive::OMPD_distribute_simd,
+ {
+ llvm::omp::allowedClauses_OMPD_distribute_simd,
+ llvm::omp::allowedOnceClauses_OMPD_distribute_simd,
+ llvm::omp::allowedExclusiveClauses_OMPD_distribute_simd,
+ llvm::omp::requiredClauses_OMPD_distribute_simd,
+ }
+ },
+ {llvm::omp::Directive::OMPD_do,
+ {
+ llvm::omp::allowedClauses_OMPD_do,
+ llvm::omp::allowedOnceClauses_OMPD_do,
+ llvm::omp::allowedExclusiveClauses_OMPD_do,
+ llvm::omp::requiredClauses_OMPD_do,
+ }
+ },
+ {llvm::omp::Directive::OMPD_do_simd,
+ {
+ llvm::omp::allowedClauses_OMPD_do_simd,
+ llvm::omp::allowedOnceClauses_OMPD_do_simd,
+ llvm::omp::allowedExclusiveClauses_OMPD_do_simd,
+ llvm::omp::requiredClauses_OMPD_do_simd,
+ }
+ },
+ {llvm::omp::Directive::OMPD_end_assumes,
+ {
+ llvm::omp::allowedClauses_OMPD_end_assumes,
+ llvm::omp::allowedOnceClauses_OMPD_end_assumes,
+ llvm::omp::allowedExclusiveClauses_OMPD_end_assumes,
+ llvm::omp::requiredClauses_OMPD_end_assumes,
+ }
+ },
+ {llvm::omp::Directive::OMPD_end_declare_target,
+ {
+ llvm::omp::allowedClauses_OMPD_end_declare_target,
+ llvm::omp::allowedOnceClauses_OMPD_end_declare_target,
+ llvm::omp::allowedExclusiveClauses_OMPD_end_declare_target,
+ llvm::omp::requiredClauses_OMPD_end_declare_target,
+ }
+ },
+ {llvm::omp::Directive::OMPD_end_declare_variant,
+ {
+ llvm::omp::allowedClauses_OMPD_end_declare_variant,
+ llvm::omp::allowedOnceClauses_OMPD_end_declare_variant,
+ llvm::omp::allowedExclusiveClauses_OMPD_end_declare_variant,
+ llvm::omp::requiredClauses_OMPD_end_declare_variant,
+ }
+ },
+ {llvm::omp::Directive::OMPD_end_do,
+ {
+ llvm::omp::allowedClauses_OMPD_end_do,
+ llvm::omp::allowedOnceClauses_OMPD_end_do,
+ llvm::omp::allowedExclusiveClauses_OMPD_end_do,
+ llvm::omp::requiredClauses_OMPD_end_do,
+ }
+ },
+ {llvm::omp::Directive::OMPD_end_do_simd,
+ {
+ llvm::omp::allowedClauses_OMPD_end_do_simd,
+ llvm::omp::allowedOnceClauses_OMPD_end_do_simd,
+ llvm::omp::allowedExclusiveClauses_OMPD_end_do_simd,
+ llvm::omp::requiredClauses_OMPD_end_do_simd,
+ }
+ },
+ {llvm::omp::Directive::OMPD_end_sections,
+ {
+ llvm::omp::allowedClauses_OMPD_end_sections,
+ llvm::omp::allowedOnceClauses_OMPD_end_sections,
+ llvm::omp::allowedExclusiveClauses_OMPD_end_sections,
+ llvm::omp::requiredClauses_OMPD_end_sections,
+ }
+ },
+ {llvm::omp::Directive::OMPD_end_single,
+ {
+ llvm::omp::allowedClauses_OMPD_end_single,
+ llvm::omp::allowedOnceClauses_OMPD_end_single,
+ llvm::omp::allowedExclusiveClauses_OMPD_end_single,
+ llvm::omp::requiredClauses_OMPD_end_single,
+ }
+ },
+ {llvm::omp::Directive::OMPD_end_workshare,
+ {
+ llvm::omp::allowedClauses_OMPD_end_workshare,
+ llvm::omp::allowedOnceClauses_OMPD_end_workshare,
+ llvm::omp::allowedExclusiveClauses_OMPD_end_workshare,
+ llvm::omp::requiredClauses_OMPD_end_workshare,
+ }
+ },
+ {llvm::omp::Directive::OMPD_flush,
+ {
+ llvm::omp::allowedClauses_OMPD_flush,
+ llvm::omp::allowedOnceClauses_OMPD_flush,
+ llvm::omp::allowedExclusiveClauses_OMPD_flush,
+ llvm::omp::requiredClauses_OMPD_flush,
+ }
+ },
+ {llvm::omp::Directive::OMPD_for,
+ {
+ llvm::omp::allowedClauses_OMPD_for,
+ llvm::omp::allowedOnceClauses_OMPD_for,
+ llvm::omp::allowedExclusiveClauses_OMPD_for,
+ llvm::omp::requiredClauses_OMPD_for,
+ }
+ },
+ {llvm::omp::Directive::OMPD_for_simd,
+ {
+ llvm::omp::allowedClauses_OMPD_for_simd,
+ llvm::omp::allowedOnceClauses_OMPD_for_simd,
+ llvm::omp::allowedExclusiveClauses_OMPD_for_simd,
+ llvm::omp::requiredClauses_OMPD_for_simd,
+ }
+ },
+ {llvm::omp::Directive::OMPD_master,
+ {
+ llvm::omp::allowedClauses_OMPD_master,
+ llvm::omp::allowedOnceClauses_OMPD_master,
+ llvm::omp::allowedExclusiveClauses_OMPD_master,
+ llvm::omp::requiredClauses_OMPD_master,
+ }
+ },
+ {llvm::omp::Directive::OMPD_master_taskloop,
+ {
+ llvm::omp::allowedClauses_OMPD_master_taskloop,
+ llvm::omp::allowedOnceClauses_OMPD_master_taskloop,
+ llvm::omp::allowedExclusiveClauses_OMPD_master_taskloop,
+ llvm::omp::requiredClauses_OMPD_master_taskloop,
+ }
+ },
+ {llvm::omp::Directive::OMPD_master_taskloop_simd,
+ {
+ llvm::omp::allowedClauses_OMPD_master_taskloop_simd,
+ llvm::omp::allowedOnceClauses_OMPD_master_taskloop_simd,
+ llvm::omp::allowedExclusiveClauses_OMPD_master_taskloop_simd,
+ llvm::omp::requiredClauses_OMPD_master_taskloop_simd,
+ }
+ },
+ {llvm::omp::Directive::OMPD_ordered,
+ {
+ llvm::omp::allowedClauses_OMPD_ordered,
+ llvm::omp::allowedOnceClauses_OMPD_ordered,
+ llvm::omp::allowedExclusiveClauses_OMPD_ordered,
+ llvm::omp::requiredClauses_OMPD_ordered,
+ }
+ },
+ {llvm::omp::Directive::OMPD_parallel,
+ {
+ llvm::omp::allowedClauses_OMPD_parallel,
+ llvm::omp::allowedOnceClauses_OMPD_parallel,
+ llvm::omp::allowedExclusiveClauses_OMPD_parallel,
+ llvm::omp::requiredClauses_OMPD_parallel,
+ }
+ },
+ {llvm::omp::Directive::OMPD_parallel_do,
+ {
+ llvm::omp::allowedClauses_OMPD_parallel_do,
+ llvm::omp::allowedOnceClauses_OMPD_parallel_do,
+ llvm::omp::allowedExclusiveClauses_OMPD_parallel_do,
+ llvm::omp::requiredClauses_OMPD_parallel_do,
+ }
+ },
+ {llvm::omp::Directive::OMPD_parallel_do_simd,
+ {
+ llvm::omp::allowedClauses_OMPD_parallel_do_simd,
+ llvm::omp::allowedOnceClauses_OMPD_parallel_do_simd,
+ llvm::omp::allowedExclusiveClauses_OMPD_parallel_do_simd,
+ llvm::omp::requiredClauses_OMPD_parallel_do_simd,
+ }
+ },
+ {llvm::omp::Directive::OMPD_parallel_for,
+ {
+ llvm::omp::allowedClauses_OMPD_parallel_for,
+ llvm::omp::allowedOnceClauses_OMPD_parallel_for,
+ llvm::omp::allowedExclusiveClauses_OMPD_parallel_for,
+ llvm::omp::requiredClauses_OMPD_parallel_for,
+ }
+ },
+ {llvm::omp::Directive::OMPD_parallel_for_simd,
+ {
+ llvm::omp::allowedClauses_OMPD_parallel_for_simd,
+ llvm::omp::allowedOnceClauses_OMPD_parallel_for_simd,
+ llvm::omp::allowedExclusiveClauses_OMPD_parallel_for_simd,
+ llvm::omp::requiredClauses_OMPD_parallel_for_simd,
+ }
+ },
+ {llvm::omp::Directive::OMPD_parallel_master,
+ {
+ llvm::omp::allowedClauses_OMPD_parallel_master,
+ llvm::omp::allowedOnceClauses_OMPD_parallel_master,
+ llvm::omp::allowedExclusiveClauses_OMPD_parallel_master,
+ llvm::omp::requiredClauses_OMPD_parallel_master,
+ }
+ },
+ {llvm::omp::Directive::OMPD_parallel_master_taskloop,
+ {
+ llvm::omp::allowedClauses_OMPD_parallel_master_taskloop,
+ llvm::omp::allowedOnceClauses_OMPD_parallel_master_taskloop,
+ llvm::omp::allowedExclusiveClauses_OMPD_parallel_master_taskloop,
+ llvm::omp::requiredClauses_OMPD_parallel_master_taskloop,
+ }
+ },
+ {llvm::omp::Directive::OMPD_parallel_master_taskloop_simd,
+ {
+ llvm::omp::allowedClauses_OMPD_parallel_master_taskloop_simd,
+ llvm::omp::allowedOnceClauses_OMPD_parallel_master_taskloop_simd,
+ llvm::omp::allowedExclusiveClauses_OMPD_parallel_master_taskloop_simd,
+ llvm::omp::requiredClauses_OMPD_parallel_master_taskloop_simd,
+ }
+ },
+ {llvm::omp::Directive::OMPD_parallel_sections,
+ {
+ llvm::omp::allowedClauses_OMPD_parallel_sections,
+ llvm::omp::allowedOnceClauses_OMPD_parallel_sections,
+ llvm::omp::allowedExclusiveClauses_OMPD_parallel_sections,
+ llvm::omp::requiredClauses_OMPD_parallel_sections,
+ }
+ },
+ {llvm::omp::Directive::OMPD_parallel_workshare,
+ {
+ llvm::omp::allowedClauses_OMPD_parallel_workshare,
+ llvm::omp::allowedOnceClauses_OMPD_parallel_workshare,
+ llvm::omp::allowedExclusiveClauses_OMPD_parallel_workshare,
+ llvm::omp::requiredClauses_OMPD_parallel_workshare,
+ }
+ },
+ {llvm::omp::Directive::OMPD_requires,
+ {
+ llvm::omp::allowedClauses_OMPD_requires,
+ llvm::omp::allowedOnceClauses_OMPD_requires,
+ llvm::omp::allowedExclusiveClauses_OMPD_requires,
+ llvm::omp::requiredClauses_OMPD_requires,
+ }
+ },
+ {llvm::omp::Directive::OMPD_scan,
+ {
+ llvm::omp::allowedClauses_OMPD_scan,
+ llvm::omp::allowedOnceClauses_OMPD_scan,
+ llvm::omp::allowedExclusiveClauses_OMPD_scan,
+ llvm::omp::requiredClauses_OMPD_scan,
+ }
+ },
+ {llvm::omp::Directive::OMPD_section,
+ {
+ llvm::omp::allowedClauses_OMPD_section,
+ llvm::omp::allowedOnceClauses_OMPD_section,
+ llvm::omp::allowedExclusiveClauses_OMPD_section,
+ llvm::omp::requiredClauses_OMPD_section,
+ }
+ },
+ {llvm::omp::Directive::OMPD_sections,
+ {
+ llvm::omp::allowedClauses_OMPD_sections,
+ llvm::omp::allowedOnceClauses_OMPD_sections,
+ llvm::omp::allowedExclusiveClauses_OMPD_sections,
+ llvm::omp::requiredClauses_OMPD_sections,
+ }
+ },
+ {llvm::omp::Directive::OMPD_simd,
+ {
+ llvm::omp::allowedClauses_OMPD_simd,
+ llvm::omp::allowedOnceClauses_OMPD_simd,
+ llvm::omp::allowedExclusiveClauses_OMPD_simd,
+ llvm::omp::requiredClauses_OMPD_simd,
+ }
+ },
+ {llvm::omp::Directive::OMPD_single,
+ {
+ llvm::omp::allowedClauses_OMPD_single,
+ llvm::omp::allowedOnceClauses_OMPD_single,
+ llvm::omp::allowedExclusiveClauses_OMPD_single,
+ llvm::omp::requiredClauses_OMPD_single,
+ }
+ },
+ {llvm::omp::Directive::OMPD_target,
+ {
+ llvm::omp::allowedClauses_OMPD_target,
+ llvm::omp::allowedOnceClauses_OMPD_target,
+ llvm::omp::allowedExclusiveClauses_OMPD_target,
+ llvm::omp::requiredClauses_OMPD_target,
+ }
+ },
+ {llvm::omp::Directive::OMPD_target_data,
+ {
+ llvm::omp::allowedClauses_OMPD_target_data,
+ llvm::omp::allowedOnceClauses_OMPD_target_data,
+ llvm::omp::allowedExclusiveClauses_OMPD_target_data,
+ llvm::omp::requiredClauses_OMPD_target_data,
+ }
+ },
+ {llvm::omp::Directive::OMPD_target_enter_data,
+ {
+ llvm::omp::allowedClauses_OMPD_target_enter_data,
+ llvm::omp::allowedOnceClauses_OMPD_target_enter_data,
+ llvm::omp::allowedExclusiveClauses_OMPD_target_enter_data,
+ llvm::omp::requiredClauses_OMPD_target_enter_data,
+ }
+ },
+ {llvm::omp::Directive::OMPD_target_exit_data,
+ {
+ llvm::omp::allowedClauses_OMPD_target_exit_data,
+ llvm::omp::allowedOnceClauses_OMPD_target_exit_data,
+ llvm::omp::allowedExclusiveClauses_OMPD_target_exit_data,
+ llvm::omp::requiredClauses_OMPD_target_exit_data,
+ }
+ },
+ {llvm::omp::Directive::OMPD_target_parallel,
+ {
+ llvm::omp::allowedClauses_OMPD_target_parallel,
+ llvm::omp::allowedOnceClauses_OMPD_target_parallel,
+ llvm::omp::allowedExclusiveClauses_OMPD_target_parallel,
+ llvm::omp::requiredClauses_OMPD_target_parallel,
+ }
+ },
+ {llvm::omp::Directive::OMPD_target_parallel_do,
+ {
+ llvm::omp::allowedClauses_OMPD_target_parallel_do,
+ llvm::omp::allowedOnceClauses_OMPD_target_parallel_do,
+ llvm::omp::allowedExclusiveClauses_OMPD_target_parallel_do,
+ llvm::omp::requiredClauses_OMPD_target_parallel_do,
+ }
+ },
+ {llvm::omp::Directive::OMPD_target_parallel_do_simd,
+ {
+ llvm::omp::allowedClauses_OMPD_target_parallel_do_simd,
+ llvm::omp::allowedOnceClauses_OMPD_target_parallel_do_simd,
+ llvm::omp::allowedExclusiveClauses_OMPD_target_parallel_do_simd,
+ llvm::omp::requiredClauses_OMPD_target_parallel_do_simd,
+ }
+ },
+ {llvm::omp::Directive::OMPD_target_parallel_for,
+ {
+ llvm::omp::allowedClauses_OMPD_target_parallel_for,
+ llvm::omp::allowedOnceClauses_OMPD_target_parallel_for,
+ llvm::omp::allowedExclusiveClauses_OMPD_target_parallel_for,
+ llvm::omp::requiredClauses_OMPD_target_parallel_for,
+ }
+ },
+ {llvm::omp::Directive::OMPD_target_parallel_for_simd,
+ {
+ llvm::omp::allowedClauses_OMPD_target_parallel_for_simd,
+ llvm::omp::allowedOnceClauses_OMPD_target_parallel_for_simd,
+ llvm::omp::allowedExclusiveClauses_OMPD_target_parallel_for_simd,
+ llvm::omp::requiredClauses_OMPD_target_parallel_for_simd,
+ }
+ },
+ {llvm::omp::Directive::OMPD_target_simd,
+ {
+ llvm::omp::allowedClauses_OMPD_target_simd,
+ llvm::omp::allowedOnceClauses_OMPD_target_simd,
+ llvm::omp::allowedExclusiveClauses_OMPD_target_simd,
+ llvm::omp::requiredClauses_OMPD_target_simd,
+ }
+ },
+ {llvm::omp::Directive::OMPD_target_teams,
+ {
+ llvm::omp::allowedClauses_OMPD_target_teams,
+ llvm::omp::allowedOnceClauses_OMPD_target_teams,
+ llvm::omp::allowedExclusiveClauses_OMPD_target_teams,
+ llvm::omp::requiredClauses_OMPD_target_teams,
+ }
+ },
+ {llvm::omp::Directive::OMPD_target_teams_distribute,
+ {
+ llvm::omp::allowedClauses_OMPD_target_teams_distribute,
+ llvm::omp::allowedOnceClauses_OMPD_target_teams_distribute,
+ llvm::omp::allowedExclusiveClauses_OMPD_target_teams_distribute,
+ llvm::omp::requiredClauses_OMPD_target_teams_distribute,
+ }
+ },
+ {llvm::omp::Directive::OMPD_target_teams_distribute_parallel_do,
+ {
+ llvm::omp::allowedClauses_OMPD_target_teams_distribute_parallel_do,
+ llvm::omp::allowedOnceClauses_OMPD_target_teams_distribute_parallel_do,
+ llvm::omp::allowedExclusiveClauses_OMPD_target_teams_distribute_parallel_do,
+ llvm::omp::requiredClauses_OMPD_target_teams_distribute_parallel_do,
+ }
+ },
+ {llvm::omp::Directive::OMPD_target_teams_distribute_parallel_do_simd,
+ {
+ llvm::omp::allowedClauses_OMPD_target_teams_distribute_parallel_do_simd,
+ llvm::omp::allowedOnceClauses_OMPD_target_teams_distribute_parallel_do_simd,
+ llvm::omp::allowedExclusiveClauses_OMPD_target_teams_distribute_parallel_do_simd,
+ llvm::omp::requiredClauses_OMPD_target_teams_distribute_parallel_do_simd,
+ }
+ },
+ {llvm::omp::Directive::OMPD_target_teams_distribute_parallel_for,
+ {
+ llvm::omp::allowedClauses_OMPD_target_teams_distribute_parallel_for,
+ llvm::omp::allowedOnceClauses_OMPD_target_teams_distribute_parallel_for,
+ llvm::omp::allowedExclusiveClauses_OMPD_target_teams_distribute_parallel_for,
+ llvm::omp::requiredClauses_OMPD_target_teams_distribute_parallel_for,
+ }
+ },
+ {llvm::omp::Directive::OMPD_target_teams_distribute_parallel_for_simd,
+ {
+ llvm::omp::allowedClauses_OMPD_target_teams_distribute_parallel_for_simd,
+ llvm::omp::allowedOnceClauses_OMPD_target_teams_distribute_parallel_for_simd,
+ llvm::omp::allowedExclusiveClauses_OMPD_target_teams_distribute_parallel_for_simd,
+ llvm::omp::requiredClauses_OMPD_target_teams_distribute_parallel_for_simd,
+ }
+ },
+ {llvm::omp::Directive::OMPD_target_teams_distribute_simd,
+ {
+ llvm::omp::allowedClauses_OMPD_target_teams_distribute_simd,
+ llvm::omp::allowedOnceClauses_OMPD_target_teams_distribute_simd,
+ llvm::omp::allowedExclusiveClauses_OMPD_target_teams_distribute_simd,
+ llvm::omp::requiredClauses_OMPD_target_teams_distribute_simd,
+ }
+ },
+ {llvm::omp::Directive::OMPD_target_update,
+ {
+ llvm::omp::allowedClauses_OMPD_target_update,
+ llvm::omp::allowedOnceClauses_OMPD_target_update,
+ llvm::omp::allowedExclusiveClauses_OMPD_target_update,
+ llvm::omp::requiredClauses_OMPD_target_update,
+ }
+ },
+ {llvm::omp::Directive::OMPD_task,
+ {
+ llvm::omp::allowedClauses_OMPD_task,
+ llvm::omp::allowedOnceClauses_OMPD_task,
+ llvm::omp::allowedExclusiveClauses_OMPD_task,
+ llvm::omp::requiredClauses_OMPD_task,
+ }
+ },
+ {llvm::omp::Directive::OMPD_taskgroup,
+ {
+ llvm::omp::allowedClauses_OMPD_taskgroup,
+ llvm::omp::allowedOnceClauses_OMPD_taskgroup,
+ llvm::omp::allowedExclusiveClauses_OMPD_taskgroup,
+ llvm::omp::requiredClauses_OMPD_taskgroup,
+ }
+ },
+ {llvm::omp::Directive::OMPD_taskloop,
+ {
+ llvm::omp::allowedClauses_OMPD_taskloop,
+ llvm::omp::allowedOnceClauses_OMPD_taskloop,
+ llvm::omp::allowedExclusiveClauses_OMPD_taskloop,
+ llvm::omp::requiredClauses_OMPD_taskloop,
+ }
+ },
+ {llvm::omp::Directive::OMPD_taskloop_simd,
+ {
+ llvm::omp::allowedClauses_OMPD_taskloop_simd,
+ llvm::omp::allowedOnceClauses_OMPD_taskloop_simd,
+ llvm::omp::allowedExclusiveClauses_OMPD_taskloop_simd,
+ llvm::omp::requiredClauses_OMPD_taskloop_simd,
+ }
+ },
+ {llvm::omp::Directive::OMPD_taskwait,
+ {
+ llvm::omp::allowedClauses_OMPD_taskwait,
+ llvm::omp::allowedOnceClauses_OMPD_taskwait,
+ llvm::omp::allowedExclusiveClauses_OMPD_taskwait,
+ llvm::omp::requiredClauses_OMPD_taskwait,
+ }
+ },
+ {llvm::omp::Directive::OMPD_taskyield,
+ {
+ llvm::omp::allowedClauses_OMPD_taskyield,
+ llvm::omp::allowedOnceClauses_OMPD_taskyield,
+ llvm::omp::allowedExclusiveClauses_OMPD_taskyield,
+ llvm::omp::requiredClauses_OMPD_taskyield,
+ }
+ },
+ {llvm::omp::Directive::OMPD_teams,
+ {
+ llvm::omp::allowedClauses_OMPD_teams,
+ llvm::omp::allowedOnceClauses_OMPD_teams,
+ llvm::omp::allowedExclusiveClauses_OMPD_teams,
+ llvm::omp::requiredClauses_OMPD_teams,
+ }
+ },
+ {llvm::omp::Directive::OMPD_teams_distribute,
+ {
+ llvm::omp::allowedClauses_OMPD_teams_distribute,
+ llvm::omp::allowedOnceClauses_OMPD_teams_distribute,
+ llvm::omp::allowedExclusiveClauses_OMPD_teams_distribute,
+ llvm::omp::requiredClauses_OMPD_teams_distribute,
+ }
+ },
+ {llvm::omp::Directive::OMPD_teams_distribute_parallel_do,
+ {
+ llvm::omp::allowedClauses_OMPD_teams_distribute_parallel_do,
+ llvm::omp::allowedOnceClauses_OMPD_teams_distribute_parallel_do,
+ llvm::omp::allowedExclusiveClauses_OMPD_teams_distribute_parallel_do,
+ llvm::omp::requiredClauses_OMPD_teams_distribute_parallel_do,
+ }
+ },
+ {llvm::omp::Directive::OMPD_teams_distribute_parallel_do_simd,
+ {
+ llvm::omp::allowedClauses_OMPD_teams_distribute_parallel_do_simd,
+ llvm::omp::allowedOnceClauses_OMPD_teams_distribute_parallel_do_simd,
+ llvm::omp::allowedExclusiveClauses_OMPD_teams_distribute_parallel_do_simd,
+ llvm::omp::requiredClauses_OMPD_teams_distribute_parallel_do_simd,
+ }
+ },
+ {llvm::omp::Directive::OMPD_teams_distribute_parallel_for,
+ {
+ llvm::omp::allowedClauses_OMPD_teams_distribute_parallel_for,
+ llvm::omp::allowedOnceClauses_OMPD_teams_distribute_parallel_for,
+ llvm::omp::allowedExclusiveClauses_OMPD_teams_distribute_parallel_for,
+ llvm::omp::requiredClauses_OMPD_teams_distribute_parallel_for,
+ }
+ },
+ {llvm::omp::Directive::OMPD_teams_distribute_parallel_for_simd,
+ {
+ llvm::omp::allowedClauses_OMPD_teams_distribute_parallel_for_simd,
+ llvm::omp::allowedOnceClauses_OMPD_teams_distribute_parallel_for_simd,
+ llvm::omp::allowedExclusiveClauses_OMPD_teams_distribute_parallel_for_simd,
+ llvm::omp::requiredClauses_OMPD_teams_distribute_parallel_for_simd,
+ }
+ },
+ {llvm::omp::Directive::OMPD_teams_distribute_simd,
+ {
+ llvm::omp::allowedClauses_OMPD_teams_distribute_simd,
+ llvm::omp::allowedOnceClauses_OMPD_teams_distribute_simd,
+ llvm::omp::allowedExclusiveClauses_OMPD_teams_distribute_simd,
+ llvm::omp::requiredClauses_OMPD_teams_distribute_simd,
+ }
+ },
+ {llvm::omp::Directive::OMPD_threadprivate,
+ {
+ llvm::omp::allowedClauses_OMPD_threadprivate,
+ llvm::omp::allowedOnceClauses_OMPD_threadprivate,
+ llvm::omp::allowedExclusiveClauses_OMPD_threadprivate,
+ llvm::omp::requiredClauses_OMPD_threadprivate,
+ }
+ },
+ {llvm::omp::Directive::OMPD_unknown,
+ {
+ llvm::omp::allowedClauses_OMPD_unknown,
+ llvm::omp::allowedOnceClauses_OMPD_unknown,
+ llvm::omp::allowedExclusiveClauses_OMPD_unknown,
+ llvm::omp::requiredClauses_OMPD_unknown,
+ }
+ },
+ {llvm::omp::Directive::OMPD_workshare,
+ {
+ llvm::omp::allowedClauses_OMPD_workshare,
+ llvm::omp::allowedOnceClauses_OMPD_workshare,
+ llvm::omp::allowedExclusiveClauses_OMPD_workshare,
+ llvm::omp::requiredClauses_OMPD_workshare,
+ }
+ },
+}
+
+#endif // GEN_FLANG_DIRECTIVE_CLAUSE_MAP
+
+#ifdef GEN_FLANG_CLAUSE_PARSER_CLASSES
+#undef GEN_FLANG_CLAUSE_PARSER_CLASSES
+
+EMPTY_CLASS(AcqRel);
+EMPTY_CLASS(Acquire);
+EMPTY_CLASS(Affinity);
+WRAPPER_CLASS(Allocate, OmpAllocateClause);
+WRAPPER_CLASS(Allocator, ScalarIntExpr);
+EMPTY_CLASS(AtomicDefaultMemOrder);
+EMPTY_CLASS(Capture);
+WRAPPER_CLASS(Collapse, ScalarIntConstantExpr);
+WRAPPER_CLASS(Copyprivate, OmpObjectList);
+WRAPPER_CLASS(Copyin, OmpObjectList);
+WRAPPER_CLASS(Default, OmpDefaultClause);
+EMPTY_CLASS(Depobj);
+EMPTY_CLASS(Destroy);
+EMPTY_CLASS(Detach);
+WRAPPER_CLASS(Device, ScalarIntExpr);
+EMPTY_CLASS(DeviceType);
+WRAPPER_CLASS(DistSchedule, std::optional<ScalarIntExpr>);
+EMPTY_CLASS(DynamicAllocators);
+EMPTY_CLASS(Exclusive);
+WRAPPER_CLASS(Final, ScalarLogicalExpr);
+WRAPPER_CLASS(Firstprivate, OmpObjectList);
+EMPTY_CLASS(Flush);
+WRAPPER_CLASS(From, OmpObjectList);
+WRAPPER_CLASS(Grainsize, ScalarIntExpr);
+WRAPPER_CLASS(Hint, ConstantExpr);
+EMPTY_CLASS(InReduction);
+EMPTY_CLASS(Inbranch);
+EMPTY_CLASS(Inclusive);
+WRAPPER_CLASS(IsDevicePtr, std::list<Name>);
+WRAPPER_CLASS(Lastprivate, OmpObjectList);
+WRAPPER_CLASS(Link, OmpObjectList);
+EMPTY_CLASS(Match);
+EMPTY_CLASS(Mergeable);
+EMPTY_CLASS(Nogroup);
+EMPTY_CLASS(Nowait);
+EMPTY_CLASS(Nontemporal);
+EMPTY_CLASS(Notinbranch);
+WRAPPER_CLASS(NumTasks, ScalarIntExpr);
+WRAPPER_CLASS(NumTeams, ScalarIntExpr);
+WRAPPER_CLASS(NumThreads, ScalarIntExpr);
+EMPTY_CLASS(Order);
+WRAPPER_CLASS(Ordered, std::optional<ScalarIntConstantExpr>);
+WRAPPER_CLASS(Priority, ScalarIntExpr);
+WRAPPER_CLASS(Private, OmpObjectList);
+WRAPPER_CLASS(ProcBind, OmpProcBindClause);
+EMPTY_CLASS(Read);
+WRAPPER_CLASS(Reduction, OmpReductionClause);
+EMPTY_CLASS(Relaxed);
+EMPTY_CLASS(Release);
+EMPTY_CLASS(ReverseOffload);
+WRAPPER_CLASS(Safelen, ScalarIntConstantExpr);
+EMPTY_CLASS(SeqCst);
+WRAPPER_CLASS(Shared, OmpObjectList);
+EMPTY_CLASS(Simd);
+WRAPPER_CLASS(Simdlen, ScalarIntConstantExpr);
+WRAPPER_CLASS(TaskReduction, OmpReductionClause);
+WRAPPER_CLASS(ThreadLimit, ScalarIntExpr);
+EMPTY_CLASS(Threadprivate);
+EMPTY_CLASS(Threads);
+WRAPPER_CLASS(To, OmpObjectList);
+EMPTY_CLASS(UnifiedAddress);
+EMPTY_CLASS(UnifiedSharedMemory);
+WRAPPER_CLASS(Uniform, std::list<Name>);
+EMPTY_CLASS(Unknown);
+EMPTY_CLASS(Untied);
+EMPTY_CLASS(Update);
+EMPTY_CLASS(UseDeviceAddr);
+WRAPPER_CLASS(UseDevicePtr, std::list<Name>);
+EMPTY_CLASS(UsesAllocators);
+EMPTY_CLASS(Write);
+
+#endif // GEN_FLANG_CLAUSE_PARSER_CLASSES
+
+#ifdef GEN_FLANG_CLAUSE_PARSER_CLASSES_LIST
+#undef GEN_FLANG_CLAUSE_PARSER_CLASSES_LIST
+
+AcqRel
+, Acquire
+, Affinity
+, OmpAlignedClause
+, Allocate
+, Allocator
+, AtomicDefaultMemOrder
+, Capture
+, Collapse
+, Copyprivate
+, Copyin
+, Default
+, OmpDefaultmapClause
+, OmpDependClause
+, Depobj
+, Destroy
+, Detach
+, Device
+, DeviceType
+, DistSchedule
+, DynamicAllocators
+, Exclusive
+, Final
+, Firstprivate
+, Flush
+, From
+, Grainsize
+, Hint
+, OmpIfClause
+, InReduction
+, Inbranch
+, Inclusive
+, IsDevicePtr
+, Lastprivate
+, OmpLinearClause
+, Link
+, OmpMapClause
+, Match
+, Mergeable
+, Nogroup
+, Nowait
+, Nontemporal
+, Notinbranch
+, NumTasks
+, NumTeams
+, NumThreads
+, Order
+, Ordered
+, Priority
+, Private
+, ProcBind
+, Read
+, Reduction
+, Relaxed
+, Release
+, ReverseOffload
+, Safelen
+, OmpScheduleClause
+, SeqCst
+, Shared
+, Simd
+, Simdlen
+, TaskReduction
+, ThreadLimit
+, Threadprivate
+, Threads
+, To
+, UnifiedAddress
+, UnifiedSharedMemory
+, Uniform
+, Unknown
+, Untied
+, Update
+, UseDeviceAddr
+, UseDevicePtr
+, UsesAllocators
+, Write
+
+#endif // GEN_FLANG_CLAUSE_PARSER_CLASSES_LIST
+
+#ifdef GEN_FLANG_DUMP_PARSE_TREE_CLAUSES
+#undef GEN_FLANG_DUMP_PARSE_TREE_CLAUSES
+
+NODE(OmpClause, AcqRel)
+NODE(OmpClause, Acquire)
+NODE(OmpClause, Affinity)
+NODE(OmpClause, Allocate)
+NODE(OmpClause, Allocator)
+NODE(OmpClause, AtomicDefaultMemOrder)
+NODE(OmpClause, Capture)
+NODE(OmpClause, Collapse)
+NODE(OmpClause, Copyprivate)
+NODE(OmpClause, Copyin)
+NODE(OmpClause, Default)
+NODE(OmpClause, Depobj)
+NODE(OmpClause, Destroy)
+NODE(OmpClause, Detach)
+NODE(OmpClause, Device)
+NODE(OmpClause, DeviceType)
+NODE(OmpClause, DistSchedule)
+NODE(OmpClause, DynamicAllocators)
+NODE(OmpClause, Exclusive)
+NODE(OmpClause, Final)
+NODE(OmpClause, Firstprivate)
+NODE(OmpClause, Flush)
+NODE(OmpClause, From)
+NODE(OmpClause, Grainsize)
+NODE(OmpClause, Hint)
+NODE(OmpClause, InReduction)
+NODE(OmpClause, Inbranch)
+NODE(OmpClause, Inclusive)
+NODE(OmpClause, IsDevicePtr)
+NODE(OmpClause, Lastprivate)
+NODE(OmpClause, Link)
+NODE(OmpClause, Match)
+NODE(OmpClause, Mergeable)
+NODE(OmpClause, Nogroup)
+NODE(OmpClause, Nowait)
+NODE(OmpClause, Nontemporal)
+NODE(OmpClause, Notinbranch)
+NODE(OmpClause, NumTasks)
+NODE(OmpClause, NumTeams)
+NODE(OmpClause, NumThreads)
+NODE(OmpClause, Order)
+NODE(OmpClause, Ordered)
+NODE(OmpClause, Priority)
+NODE(OmpClause, Private)
+NODE(OmpClause, ProcBind)
+NODE(OmpClause, Read)
+NODE(OmpClause, Reduction)
+NODE(OmpClause, Relaxed)
+NODE(OmpClause, Release)
+NODE(OmpClause, ReverseOffload)
+NODE(OmpClause, Safelen)
+NODE(OmpClause, SeqCst)
+NODE(OmpClause, Shared)
+NODE(OmpClause, Simd)
+NODE(OmpClause, Simdlen)
+NODE(OmpClause, TaskReduction)
+NODE(OmpClause, ThreadLimit)
+NODE(OmpClause, Threadprivate)
+NODE(OmpClause, Threads)
+NODE(OmpClause, To)
+NODE(OmpClause, UnifiedAddress)
+NODE(OmpClause, UnifiedSharedMemory)
+NODE(OmpClause, Uniform)
+NODE(OmpClause, Unknown)
+NODE(OmpClause, Untied)
+NODE(OmpClause, Update)
+NODE(OmpClause, UseDeviceAddr)
+NODE(OmpClause, UseDevicePtr)
+NODE(OmpClause, UsesAllocators)
+NODE(OmpClause, Write)
+
+#endif // GEN_FLANG_DUMP_PARSE_TREE_CLAUSES
+
+#ifdef GEN_FLANG_CLAUSE_UNPARSE
+#undef GEN_FLANG_CLAUSE_UNPARSE
+
+void Before(const OmpClause::AcqRel &) { Word("ACQ_REL"); }
+void Before(const OmpClause::Acquire &) { Word("ACQUIRE"); }
+void Before(const OmpClause::Affinity &) { Word("AFFINITY"); }
+void Unparse(const OmpClause::Allocate &x) {
+ Word("ALLOCATE");
+ Put("(");
+ Walk(x.v);
+ Put(")");
+}
+void Unparse(const OmpClause::Allocator &x) {
+ Word("ALLOCATOR");
+ Put("(");
+ Walk(x.v);
+ Put(")");
+}
+void Before(const OmpClause::AtomicDefaultMemOrder &) { Word("ATOMIC_DEFAULT_MEM_ORDER"); }
+void Before(const OmpClause::Capture &) { Word("CAPTURE"); }
+void Unparse(const OmpClause::Collapse &x) {
+ Word("COLLAPSE");
+ Put("(");
+ Walk(x.v);
+ Put(")");
+}
+void Unparse(const OmpClause::Copyprivate &x) {
+ Word("COPYPRIVATE");
+ Put("(");
+ Walk(x.v);
+ Put(")");
+}
+void Unparse(const OmpClause::Copyin &x) {
+ Word("COPYIN");
+ Put("(");
+ Walk(x.v);
+ Put(")");
+}
+void Unparse(const OmpClause::Default &x) {
+ Word("DEFAULT");
+ Put("(");
+ Walk(x.v);
+ Put(")");
+}
+void Before(const OmpClause::Depobj &) { Word("DEPOBJ"); }
+void Before(const OmpClause::Destroy &) { Word("DESTROY"); }
+void Before(const OmpClause::Detach &) { Word("DETACH"); }
+void Unparse(const OmpClause::Device &x) {
+ Word("DEVICE");
+ Put("(");
+ Walk(x.v);
+ Put(")");
+}
+void Before(const OmpClause::DeviceType &) { Word("DEVICE_TYPE"); }
+void Unparse(const OmpClause::DistSchedule &x) {
+ Word("DIST_SCHEDULE");
+ Walk("(", x.v, ")");
+}
+void Before(const OmpClause::DynamicAllocators &) { Word("DYNAMIC_ALLOCATORS"); }
+void Before(const OmpClause::Exclusive &) { Word("EXCLUSIVE"); }
+void Unparse(const OmpClause::Final &x) {
+ Word("FINAL");
+ Put("(");
+ Walk(x.v);
+ Put(")");
+}
+void Unparse(const OmpClause::Firstprivate &x) {
+ Word("FIRSTPRIVATE");
+ Put("(");
+ Walk(x.v);
+ Put(")");
+}
+void Before(const OmpClause::Flush &) { Word("FLUSH"); }
+void Unparse(const OmpClause::From &x) {
+ Word("FROM");
+ Put("(");
+ Walk(x.v);
+ Put(")");
+}
+void Unparse(const OmpClause::Grainsize &x) {
+ Word("GRAINSIZE");
+ Put("(");
+ Walk(x.v);
+ Put(")");
+}
+void Unparse(const OmpClause::Hint &x) {
+ Word("HINT");
+ Put("(");
+ Walk(x.v);
+ Put(")");
+}
+void Before(const OmpClause::InReduction &) { Word("IN_REDUCTION"); }
+void Before(const OmpClause::Inbranch &) { Word("INBRANCH"); }
+void Before(const OmpClause::Inclusive &) { Word("INCLUSIVE"); }
+void Unparse(const OmpClause::IsDevicePtr &x) {
+ Word("IS_DEVICE_PTR");
+ Put("(");
+ Walk(x.v, ",");
+ Put(")");
+}
+void Unparse(const OmpClause::Lastprivate &x) {
+ Word("LASTPRIVATE");
+ Put("(");
+ Walk(x.v);
+ Put(")");
+}
+void Unparse(const OmpClause::Link &x) {
+ Word("LINK");
+ Put("(");
+ Walk(x.v);
+ Put(")");
+}
+void Before(const OmpClause::Match &) { Word("MATCH"); }
+void Before(const OmpClause::Mergeable &) { Word("MERGEABLE"); }
+void Before(const OmpClause::Nogroup &) { Word("NOGROUP"); }
+void Before(const OmpClause::Nowait &) { Word("NOWAIT"); }
+void Before(const OmpClause::Nontemporal &) { Word("NONTEMPORAL"); }
+void Before(const OmpClause::Notinbranch &) { Word("NOTINBRANCH"); }
+void Unparse(const OmpClause::NumTasks &x) {
+ Word("NUM_TASKS");
+ Put("(");
+ Walk(x.v);
+ Put(")");
+}
+void Unparse(const OmpClause::NumTeams &x) {
+ Word("NUM_TEAMS");
+ Put("(");
+ Walk(x.v);
+ Put(")");
+}
+void Unparse(const OmpClause::NumThreads &x) {
+ Word("NUM_THREADS");
+ Put("(");
+ Walk(x.v);
+ Put(")");
+}
+void Before(const OmpClause::Order &) { Word("ORDER"); }
+void Unparse(const OmpClause::Ordered &x) {
+ Word("ORDERED");
+ Walk("(", x.v, ")");
+}
+void Unparse(const OmpClause::Priority &x) {
+ Word("PRIORITY");
+ Put("(");
+ Walk(x.v);
+ Put(")");
+}
+void Unparse(const OmpClause::Private &x) {
+ Word("PRIVATE");
+ Put("(");
+ Walk(x.v);
+ Put(")");
+}
+void Unparse(const OmpClause::ProcBind &x) {
+ Word("PROC_BIND");
+ Put("(");
+ Walk(x.v);
+ Put(")");
+}
+void Before(const OmpClause::Read &) { Word("READ"); }
+void Unparse(const OmpClause::Reduction &x) {
+ Word("REDUCTION");
+ Put("(");
+ Walk(x.v);
+ Put(")");
+}
+void Before(const OmpClause::Relaxed &) { Word("RELAXED"); }
+void Before(const OmpClause::Release &) { Word("RELEASE"); }
+void Before(const OmpClause::ReverseOffload &) { Word("REVERSE_OFFLOAD"); }
+void Unparse(const OmpClause::Safelen &x) {
+ Word("SAFELEN");
+ Put("(");
+ Walk(x.v);
+ Put(")");
+}
+void Before(const OmpClause::SeqCst &) { Word("SEQ_CST"); }
+void Unparse(const OmpClause::Shared &x) {
+ Word("SHARED");
+ Put("(");
+ Walk(x.v);
+ Put(")");
+}
+void Before(const OmpClause::Simd &) { Word("SIMD"); }
+void Unparse(const OmpClause::Simdlen &x) {
+ Word("SIMDLEN");
+ Put("(");
+ Walk(x.v);
+ Put(")");
+}
+void Unparse(const OmpClause::TaskReduction &x) {
+ Word("TASK_REDUCTION");
+ Put("(");
+ Walk(x.v);
+ Put(")");
+}
+void Unparse(const OmpClause::ThreadLimit &x) {
+ Word("THREAD_LIMIT");
+ Put("(");
+ Walk(x.v);
+ Put(")");
+}
+void Before(const OmpClause::Threadprivate &) { Word("THREADPRIVATE"); }
+void Before(const OmpClause::Threads &) { Word("THREADS"); }
+void Unparse(const OmpClause::To &x) {
+ Word("TO");
+ Put("(");
+ Walk(x.v);
+ Put(")");
+}
+void Before(const OmpClause::UnifiedAddress &) { Word("UNIFIED_ADDRESS"); }
+void Before(const OmpClause::UnifiedSharedMemory &) { Word("UNIFIED_SHARED_MEMORY"); }
+void Unparse(const OmpClause::Uniform &x) {
+ Word("UNIFORM");
+ Put("(");
+ Walk(x.v, ",");
+ Put(")");
+}
+void Before(const OmpClause::Unknown &) { Word("UNKNOWN"); }
+void Before(const OmpClause::Untied &) { Word("UNTIED"); }
+void Before(const OmpClause::Update &) { Word("UPDATE"); }
+void Before(const OmpClause::UseDeviceAddr &) { Word("USE_DEVICE_ADDR"); }
+void Unparse(const OmpClause::UseDevicePtr &x) {
+ Word("USE_DEVICE_PTR");
+ Put("(");
+ Walk(x.v, ",");
+ Put(")");
+}
+void Before(const OmpClause::UsesAllocators &) { Word("USES_ALLOCATORS"); }
+void Before(const OmpClause::Write &) { Word("WRITE"); }
+
+#endif // GEN_FLANG_CLAUSE_UNPARSE
+
+#ifdef GEN_CLANG_CLAUSE_CLASS
+#undef GEN_CLANG_CLAUSE_CLASS
+
+#ifndef CLAUSE
+#define CLAUSE(Enum, Str, Implicit)
+#endif
+#ifndef CLAUSE_CLASS
+#define CLAUSE_CLASS(Enum, Str, Class)
+#endif
+#ifndef CLAUSE_NO_CLASS
+#define CLAUSE_NO_CLASS(Enum, Str)
+#endif
+
+#define __CLAUSE(Name, Class) \
+ CLAUSE(OMPC_##Name, #Name, /* Implicit */ false) \
+ CLAUSE_CLASS(OMPC_##Name, #Name, Class)
+#define __CLAUSE_NO_CLASS(Name) \
+ CLAUSE(OMPC_##Name, #Name, /* Implicit */ false) \
+ CLAUSE_NO_CLASS(OMPC_##Name, #Name)
+#define __IMPLICIT_CLAUSE_CLASS(Name, Str, Class) \
+ CLAUSE(OMPC_##Name, Str, /* Implicit */ true) \
+ CLAUSE_CLASS(OMPC_##Name, Str, Class)
+#define __IMPLICIT_CLAUSE_NO_CLASS(Name, Str) \
+ CLAUSE(OMPC_##Name, Str, /* Implicit */ true) \
+ CLAUSE_NO_CLASS(OMPC_##Name, Str)
+
+__CLAUSE(acq_rel, OMPAcqRelClause)
+__CLAUSE(acquire, OMPAcquireClause)
+__CLAUSE(affinity, OMPAffinityClause)
+__CLAUSE(aligned, OMPAlignedClause)
+__CLAUSE(allocate, OMPAllocateClause)
+__CLAUSE(allocator, OMPAllocatorClause)
+__CLAUSE(atomic_default_mem_order, OMPAtomicDefaultMemOrderClause)
+__CLAUSE(capture, OMPCaptureClause)
+__CLAUSE(collapse, OMPCollapseClause)
+__CLAUSE(copyprivate, OMPCopyprivateClause)
+__CLAUSE(copyin, OMPCopyinClause)
+__CLAUSE(default, OMPDefaultClause)
+__CLAUSE(defaultmap, OMPDefaultmapClause)
+__CLAUSE(depend, OMPDependClause)
+__IMPLICIT_CLAUSE_CLASS(depobj, "depobj", OMPDepobjClause)
+__CLAUSE(destroy, OMPDestroyClause)
+__CLAUSE(detach, OMPDetachClause)
+__CLAUSE(device, OMPDeviceClause)
+__CLAUSE_NO_CLASS(device_type)
+__CLAUSE(dist_schedule, OMPDistScheduleClause)
+__CLAUSE(dynamic_allocators, OMPDynamicAllocatorsClause)
+__CLAUSE(exclusive, OMPExclusiveClause)
+__CLAUSE(final, OMPFinalClause)
+__CLAUSE(firstprivate, OMPFirstprivateClause)
+__IMPLICIT_CLAUSE_CLASS(flush, "flush", OMPFlushClause)
+__CLAUSE(from, OMPFromClause)
+__CLAUSE(grainsize, OMPGrainsizeClause)
+__CLAUSE(hint, OMPHintClause)
+__CLAUSE(if, OMPIfClause)
+__CLAUSE(in_reduction, OMPInReductionClause)
+__CLAUSE_NO_CLASS(inbranch)
+__CLAUSE(inclusive, OMPInclusiveClause)
+__CLAUSE(is_device_ptr, OMPIsDevicePtrClause)
+__CLAUSE(lastprivate, OMPLastprivateClause)
+__CLAUSE(linear, OMPLinearClause)
+__CLAUSE_NO_CLASS(link)
+__CLAUSE(map, OMPMapClause)
+__CLAUSE_NO_CLASS(match)
+__CLAUSE(mergeable, OMPMergeableClause)
+__CLAUSE(nogroup, OMPNogroupClause)
+__CLAUSE(nowait, OMPNowaitClause)
+__CLAUSE(nontemporal, OMPNontemporalClause)
+__CLAUSE_NO_CLASS(notinbranch)
+__CLAUSE(num_tasks, OMPNumTasksClause)
+__CLAUSE(num_teams, OMPNumTeamsClause)
+__CLAUSE(num_threads, OMPNumThreadsClause)
+__CLAUSE(order, OMPOrderClause)
+__CLAUSE(ordered, OMPOrderedClause)
+__CLAUSE(priority, OMPPriorityClause)
+__CLAUSE(private, OMPPrivateClause)
+__CLAUSE(proc_bind, OMPProcBindClause)
+__CLAUSE(read, OMPReadClause)
+__CLAUSE(reduction, OMPReductionClause)
+__CLAUSE(relaxed, OMPRelaxedClause)
+__CLAUSE(release, OMPReleaseClause)
+__CLAUSE(reverse_offload, OMPReverseOffloadClause)
+__CLAUSE(safelen, OMPSafelenClause)
+__CLAUSE(schedule, OMPScheduleClause)
+__CLAUSE(seq_cst, OMPSeqCstClause)
+__CLAUSE(shared, OMPSharedClause)
+__CLAUSE(simd, OMPSIMDClause)
+__CLAUSE(simdlen, OMPSimdlenClause)
+__CLAUSE(task_reduction, OMPTaskReductionClause)
+__CLAUSE(thread_limit, OMPThreadLimitClause)
+__IMPLICIT_CLAUSE_NO_CLASS(threadprivate, "threadprivate")
+__CLAUSE(threads, OMPThreadsClause)
+__CLAUSE(to, OMPToClause)
+__CLAUSE(unified_address, OMPUnifiedAddressClause)
+__CLAUSE(unified_shared_memory, OMPUnifiedSharedMemoryClause)
+__CLAUSE_NO_CLASS(uniform)
+__IMPLICIT_CLAUSE_NO_CLASS(unknown, "unknown")
+__CLAUSE(untied, OMPUntiedClause)
+__CLAUSE(update, OMPUpdateClause)
+__CLAUSE(use_device_addr, OMPUseDeviceAddrClause)
+__CLAUSE(use_device_ptr, OMPUseDevicePtrClause)
+__CLAUSE(uses_allocators, OMPUsesAllocatorsClause)
+__CLAUSE(write, OMPWriteClause)
+
+#undef __IMPLICIT_CLAUSE_NO_CLASS
+#undef __IMPLICIT_CLAUSE_CLASS
+#undef __CLAUSE
+#undef CLAUSE_NO_CLASS
+#undef CLAUSE_CLASS
+#undef CLAUSE
+
+#endif // GEN_CLANG_CLAUSE_CLASS
+
diff --git a/linux-x64/clang/include/llvm/Frontend/OpenMP/OMP.td b/linux-x64/clang/include/llvm/Frontend/OpenMP/OMP.td
new file mode 100644
index 0000000..b5b5bb2
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Frontend/OpenMP/OMP.td
@@ -0,0 +1,1639 @@
+//===-- OMP.td - OpenMP directive definition file ----------*- tablegen -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This is the definition file for OpenMP directives and clauses.
+//
+//===----------------------------------------------------------------------===//
+
+include "llvm/Frontend/Directive/DirectiveBase.td"
+
+//===----------------------------------------------------------------------===//
+// Definition of general OpenMP information
+//===----------------------------------------------------------------------===//
+
+def OpenMP : DirectiveLanguage {
+ let name = "OpenMP";
+ let cppNamespace = "omp"; // final namespace will be llvm::omp
+ let directivePrefix = "OMPD_";
+ let clausePrefix = "OMPC_";
+ let makeEnumAvailableInNamespace = true;
+ let enableBitmaskEnumInNamespace = true;
+ let includeHeader = "llvm/Frontend/OpenMP/OMP.h.inc";
+ let clauseEnumSetClass = "OmpClauseSet";
+ let flangClauseBaseClass = "OmpClause";
+}
+
+//===----------------------------------------------------------------------===//
+// Definition of OpenMP clauses
+//===----------------------------------------------------------------------===//
+
+def OMPC_Allocator : Clause<"allocator"> {
+ let clangClass = "OMPAllocatorClause";
+ let flangClassValue = "ScalarIntExpr";
+}
+def OMPC_If : Clause<"if"> {
+ let clangClass = "OMPIfClause";
+ let flangClass = "OmpIfClause";
+}
+def OMPC_Final : Clause<"final"> {
+ let clangClass = "OMPFinalClause";
+ let flangClassValue = "ScalarLogicalExpr";
+}
+def OMPC_NumThreads : Clause<"num_threads"> {
+ let clangClass = "OMPNumThreadsClause";
+ let flangClassValue = "ScalarIntExpr";
+}
+def OMPC_SafeLen : Clause<"safelen"> {
+ let clangClass = "OMPSafelenClause";
+ let flangClassValue = "ScalarIntConstantExpr";
+}
+def OMPC_SimdLen : Clause<"simdlen"> {
+ let clangClass = "OMPSimdlenClause";
+ let flangClassValue = "ScalarIntConstantExpr";
+}
+def OMPC_Collapse : Clause<"collapse"> {
+ let clangClass = "OMPCollapseClause";
+ let flangClassValue = "ScalarIntConstantExpr";
+}
+def OMPC_Default : Clause<"default"> {
+ let clangClass = "OMPDefaultClause";
+ let flangClassValue = "OmpDefaultClause";
+}
+def OMPC_Private : Clause<"private"> {
+ let clangClass = "OMPPrivateClause";
+ let flangClassValue = "OmpObjectList";
+}
+def OMPC_FirstPrivate : Clause<"firstprivate"> {
+ let clangClass = "OMPFirstprivateClause";
+ let flangClassValue = "OmpObjectList";
+}
+def OMPC_LastPrivate : Clause<"lastprivate"> {
+ let clangClass = "OMPLastprivateClause";
+ let flangClassValue = "OmpObjectList";
+}
+def OMPC_Shared : Clause<"shared"> {
+ let clangClass = "OMPSharedClause";
+ let flangClassValue = "OmpObjectList";
+}
+def OMPC_Reduction : Clause<"reduction"> {
+ let clangClass = "OMPReductionClause";
+ let flangClassValue = "OmpReductionClause";
+}
+def OMPC_Linear : Clause<"linear"> {
+ let clangClass = "OMPLinearClause";
+ let flangClass = "OmpLinearClause";
+}
+def OMPC_Aligned : Clause<"aligned"> {
+ let clangClass = "OMPAlignedClause";
+ let flangClass = "OmpAlignedClause";
+}
+def OMPC_Copyin : Clause<"copyin"> {
+ let clangClass = "OMPCopyinClause";
+ let flangClassValue = "OmpObjectList";
+}
+def OMPC_CopyPrivate : Clause<"copyprivate"> {
+ let clangClass = "OMPCopyprivateClause";
+ let flangClassValue = "OmpObjectList";
+}
+def OMP_PROC_BIND_master : ClauseVal<"master",2,1> {}
+def OMP_PROC_BIND_close : ClauseVal<"close",3,1> {}
+def OMP_PROC_BIND_spread : ClauseVal<"spread",4,1> {}
+def OMP_PROC_BIND_default : ClauseVal<"default",5,0> {}
+def OMP_PROC_BIND_unknown : ClauseVal<"unknown",6,0> { let isDefault = true; }
+def OMPC_ProcBind : Clause<"proc_bind"> {
+ let clangClass = "OMPProcBindClause";
+ let flangClassValue = "OmpProcBindClause";
+ let enumClauseValue = "ProcBindKind";
+ let allowedClauseValues = [
+ OMP_PROC_BIND_master,
+ OMP_PROC_BIND_close,
+ OMP_PROC_BIND_spread,
+ OMP_PROC_BIND_default,
+ OMP_PROC_BIND_unknown
+ ];
+}
+
+// static and auto are C++ keywords so need a capital to disambiguate.
+def OMP_SCHEDULE_Static : ClauseVal<"Static", 2, 1> {}
+def OMP_SCHEDULE_Dynamic : ClauseVal<"Dynamic", 3, 1> {}
+def OMP_SCHEDULE_Guided : ClauseVal<"Guided", 4, 1> {}
+def OMP_SCHEDULE_Auto : ClauseVal<"Auto", 5, 1> {}
+def OMP_SCHEDULE_Runtime : ClauseVal<"Runtime", 6, 1> {}
+def OMP_SCHEDULE_Default : ClauseVal<"Default", 7, 0> { let isDefault = 1; }
+
+def OMPC_Schedule : Clause<"schedule"> {
+ let clangClass = "OMPScheduleClause";
+ let flangClass = "OmpScheduleClause";
+ let enumClauseValue = "ScheduleKind";
+ let allowedClauseValues = [
+ OMP_SCHEDULE_Static,
+ OMP_SCHEDULE_Dynamic,
+ OMP_SCHEDULE_Guided,
+ OMP_SCHEDULE_Auto,
+ OMP_SCHEDULE_Runtime,
+ OMP_SCHEDULE_Default
+ ];
+}
+
+def OMPC_Ordered : Clause<"ordered"> {
+ let clangClass = "OMPOrderedClause";
+ let flangClassValue = "ScalarIntConstantExpr";
+ let isValueOptional = true;
+}
+def OMPC_NoWait : Clause<"nowait"> {
+ let clangClass = "OMPNowaitClause";
+}
+def OMPC_Untied : Clause<"untied"> { let clangClass = "OMPUntiedClause"; }
+def OMPC_Mergeable : Clause<"mergeable"> {
+ let clangClass = "OMPMergeableClause";
+}
+def OMPC_Read : Clause<"read"> { let clangClass = "OMPReadClause"; }
+def OMPC_Write : Clause<"write"> { let clangClass = "OMPWriteClause"; }
+def OMPC_Update : Clause<"update"> { let clangClass = "OMPUpdateClause"; }
+def OMPC_Capture : Clause<"capture"> { let clangClass = "OMPCaptureClause"; }
+def OMPC_SeqCst : Clause<"seq_cst"> { let clangClass = "OMPSeqCstClause"; }
+def OMPC_AcqRel : Clause<"acq_rel"> { let clangClass = "OMPAcqRelClause"; }
+def OMPC_Acquire : Clause<"acquire"> { let clangClass = "OMPAcquireClause"; }
+def OMPC_Release : Clause<"release"> { let clangClass = "OMPReleaseClause"; }
+def OMPC_Relaxed : Clause<"relaxed"> { let clangClass = "OMPRelaxedClause"; }
+def OMPC_Depend : Clause<"depend"> {
+ let clangClass = "OMPDependClause";
+ let flangClass = "OmpDependClause";
+}
+def OMPC_Device : Clause<"device"> {
+ let clangClass = "OMPDeviceClause";
+ let flangClassValue = "ScalarIntExpr";
+}
+def OMPC_Threads : Clause<"threads"> { let clangClass = "OMPThreadsClause"; }
+def OMPC_Simd : Clause<"simd"> { let clangClass = "OMPSIMDClause"; }
+def OMPC_Map : Clause<"map"> {
+ let clangClass = "OMPMapClause";
+ let flangClass = "OmpMapClause";
+}
+def OMPC_NumTeams : Clause<"num_teams"> {
+ let clangClass = "OMPNumTeamsClause";
+ let flangClassValue = "ScalarIntExpr";
+}
+def OMPC_ThreadLimit : Clause<"thread_limit"> {
+ let clangClass = "OMPThreadLimitClause";
+ let flangClassValue = "ScalarIntExpr";
+}
+def OMPC_Priority : Clause<"priority"> {
+ let clangClass = "OMPPriorityClause";
+ let flangClassValue = "ScalarIntExpr";
+}
+def OMPC_GrainSize : Clause<"grainsize"> {
+ let clangClass = "OMPGrainsizeClause";
+ let flangClassValue = "ScalarIntExpr";
+}
+def OMPC_NoGroup : Clause<"nogroup"> {
+ let clangClass = "OMPNogroupClause";
+}
+def OMPC_NumTasks : Clause<"num_tasks"> {
+ let clangClass = "OMPNumTasksClause";
+ let flangClassValue = "ScalarIntExpr";
+}
+def OMPC_Hint : Clause<"hint"> {
+ let clangClass = "OMPHintClause";
+ let flangClassValue = "ConstantExpr";
+}
+def OMPC_DistSchedule : Clause<"dist_schedule"> {
+ let clangClass = "OMPDistScheduleClause";
+ let flangClassValue = "ScalarIntExpr";
+ let isValueOptional = true;
+}
+def OMPC_DefaultMap : Clause<"defaultmap"> {
+ let clangClass = "OMPDefaultmapClause";
+ let flangClass = "OmpDefaultmapClause";
+}
+def OMPC_To : Clause<"to"> {
+ let clangClass = "OMPToClause";
+ let flangClassValue = "OmpObjectList";
+}
+def OMPC_From : Clause<"from"> {
+ let clangClass = "OMPFromClause";
+ let flangClassValue = "OmpObjectList";
+}
+def OMPC_UseDevicePtr : Clause<"use_device_ptr"> {
+ let clangClass = "OMPUseDevicePtrClause";
+ let flangClassValue = "Name";
+ let isValueList = true;
+}
+def OMPC_IsDevicePtr : Clause<"is_device_ptr"> {
+ let clangClass = "OMPIsDevicePtrClause";
+ let flangClassValue = "Name";
+ let isValueList = true;
+}
+def OMPC_TaskReduction : Clause<"task_reduction"> {
+ let clangClass = "OMPTaskReductionClause";
+ let flangClassValue = "OmpReductionClause";
+}
+def OMPC_InReduction : Clause<"in_reduction"> {
+ let clangClass = "OMPInReductionClause";
+}
+def OMPC_UnifiedAddress : Clause<"unified_address"> {
+ let clangClass = "OMPUnifiedAddressClause";
+}
+def OMPC_UnifiedSharedMemory : Clause<"unified_shared_memory"> {
+ let clangClass = "OMPUnifiedSharedMemoryClause";
+}
+def OMPC_ReverseOffload : Clause<"reverse_offload"> {
+ let clangClass = "OMPReverseOffloadClause";
+}
+def OMPC_DynamicAllocators : Clause<"dynamic_allocators"> {
+ let clangClass = "OMPDynamicAllocatorsClause";
+}
+def OMPC_AtomicDefaultMemOrder : Clause<"atomic_default_mem_order"> {
+ let clangClass = "OMPAtomicDefaultMemOrderClause";
+}
+def OMPC_Allocate : Clause<"allocate"> {
+ let clangClass = "OMPAllocateClause";
+ let flangClassValue = "OmpAllocateClause";
+}
+def OMPC_NonTemporal : Clause<"nontemporal"> {
+ let clangClass = "OMPNontemporalClause";
+}
+
+def OMP_ORDER_concurrent : ClauseVal<"default",2,0> { let isDefault = 1; }
+def OMPC_Order : Clause<"order"> {
+ let clangClass = "OMPOrderClause";
+ let enumClauseValue = "OrderKind";
+ let allowedClauseValues = [
+ OMP_ORDER_concurrent
+ ];
+}
+def OMPC_Destroy : Clause<"destroy"> {
+ let clangClass = "OMPDestroyClause";
+}
+def OMPC_Detach : Clause<"detach"> {
+ let clangClass = "OMPDetachClause";
+}
+def OMPC_Inclusive : Clause<"inclusive"> {
+ let clangClass = "OMPInclusiveClause";
+}
+def OMPC_Exclusive : Clause<"exclusive"> {
+ let clangClass = "OMPExclusiveClause";
+}
+def OMPC_UsesAllocators : Clause<"uses_allocators"> {
+ let clangClass = "OMPUsesAllocatorsClause";
+}
+def OMPC_Affinity : Clause<"affinity"> {
+ let clangClass = "OMPAffinityClause";
+}
+def OMPC_UseDeviceAddr : Clause<"use_device_addr"> {
+ let clangClass = "OMPUseDeviceAddrClause";
+}
+def OMPC_Uniform : Clause<"uniform"> {
+ let flangClassValue = "Name";
+ let isValueList = true;
+}
+def OMPC_DeviceType : Clause<"device_type"> {}
+def OMPC_Match : Clause<"match"> {}
+def OMPC_Depobj : Clause<"depobj"> {
+ let clangClass = "OMPDepobjClause";
+ let isImplicit = true;
+}
+def OMPC_Flush : Clause<"flush"> {
+ let clangClass = "OMPFlushClause";
+ let isImplicit = true;
+}
+def OMPC_ThreadPrivate : Clause<"threadprivate"> {
+ let alternativeName = "threadprivate or thread local";
+ let isImplicit = true;
+}
+def OMPC_Unknown : Clause<"unknown"> {
+ let isImplicit = true;
+ let isDefault = true;
+}
+def OMPC_Link : Clause<"link"> {
+ let flangClassValue = "OmpObjectList";
+}
+def OMPC_Inbranch : Clause<"inbranch"> {}
+def OMPC_Notinbranch : Clause<"notinbranch"> {}
+
+//===----------------------------------------------------------------------===//
+// Definition of OpenMP directives
+//===----------------------------------------------------------------------===//
+
+def OMP_ThreadPrivate : Directive<"threadprivate"> {}
+def OMP_Parallel : Directive<"parallel"> {
+ let allowedClauses = [
+ VersionedClause<OMPC_Private>,
+ VersionedClause<OMPC_FirstPrivate>,
+ VersionedClause<OMPC_Shared>,
+ VersionedClause<OMPC_Reduction>,
+ VersionedClause<OMPC_Copyin>,
+ VersionedClause<OMPC_Allocate>
+ ];
+ let allowedOnceClauses = [
+ VersionedClause<OMPC_Default>,
+ VersionedClause<OMPC_If>,
+ VersionedClause<OMPC_NumThreads>,
+ VersionedClause<OMPC_ProcBind>,
+ ];
+}
+def OMP_Task : Directive<"task"> {
+ let allowedClauses = [
+ VersionedClause<OMPC_Private>,
+ VersionedClause<OMPC_FirstPrivate>,
+ VersionedClause<OMPC_Shared>,
+ VersionedClause<OMPC_Untied>,
+ VersionedClause<OMPC_Mergeable>,
+ VersionedClause<OMPC_Depend>,
+ VersionedClause<OMPC_InReduction>,
+ VersionedClause<OMPC_Allocate>,
+ VersionedClause<OMPC_Detach, 50>,
+ VersionedClause<OMPC_Affinity, 50>
+ ];
+ let allowedOnceClauses = [
+ VersionedClause<OMPC_Default>,
+ VersionedClause<OMPC_If>,
+ VersionedClause<OMPC_Final>,
+ VersionedClause<OMPC_Priority>
+ ];
+}
+def OMP_Simd : Directive<"simd"> {
+ let allowedClauses = [
+ VersionedClause<OMPC_Private>,
+ VersionedClause<OMPC_LastPrivate>,
+ VersionedClause<OMPC_Linear>,
+ VersionedClause<OMPC_Aligned>,
+ VersionedClause<OMPC_Reduction>,
+ VersionedClause<OMPC_Allocate>,
+ VersionedClause<OMPC_NonTemporal, 50>,
+ VersionedClause<OMPC_Order, 50>
+ ];
+ let allowedOnceClauses = [
+ VersionedClause<OMPC_Collapse>,
+ VersionedClause<OMPC_SafeLen>,
+ VersionedClause<OMPC_SimdLen>,
+ VersionedClause<OMPC_If, 50>,
+ ];
+}
+def OMP_For : Directive<"for"> {
+ let allowedClauses = [
+ VersionedClause<OMPC_Private>,
+ VersionedClause<OMPC_LastPrivate>,
+ VersionedClause<OMPC_FirstPrivate>,
+ VersionedClause<OMPC_Reduction>,
+ VersionedClause<OMPC_Collapse>,
+ VersionedClause<OMPC_Schedule>,
+ VersionedClause<OMPC_Ordered>,
+ VersionedClause<OMPC_NoWait>,
+ VersionedClause<OMPC_Linear>,
+ VersionedClause<OMPC_Allocate>,
+ VersionedClause<OMPC_Order, 50>
+ ];
+}
+def OMP_Do : Directive<"do"> {
+ let allowedClauses = [
+ VersionedClause<OMPC_Private>,
+ VersionedClause<OMPC_FirstPrivate>,
+ VersionedClause<OMPC_LastPrivate>,
+ VersionedClause<OMPC_Linear>,
+ VersionedClause<OMPC_Reduction>
+ ];
+ let allowedOnceClauses = [
+ VersionedClause<OMPC_Schedule>,
+ VersionedClause<OMPC_Collapse>,
+ VersionedClause<OMPC_Ordered>,
+ VersionedClause<OMPC_NoWait>
+ ];
+}
+def OMP_Sections : Directive<"sections"> {
+ let allowedClauses = [
+ VersionedClause<OMPC_Private>,
+ VersionedClause<OMPC_LastPrivate>,
+ VersionedClause<OMPC_FirstPrivate>,
+ VersionedClause<OMPC_Reduction>,
+ VersionedClause<OMPC_NoWait>,
+ VersionedClause<OMPC_Allocate>
+ ];
+}
+def OMP_Section : Directive<"section"> {}
+def OMP_Single : Directive<"single"> {
+ let allowedClauses = [
+ VersionedClause<OMPC_Private>,
+ VersionedClause<OMPC_FirstPrivate>,
+ VersionedClause<OMPC_CopyPrivate>,
+ VersionedClause<OMPC_NoWait>,
+ VersionedClause<OMPC_Allocate>
+ ];
+}
+def OMP_Master : Directive<"master"> {}
+def OMP_Critical : Directive<"critical"> {
+ let allowedClauses = [
+ VersionedClause<OMPC_Hint>
+ ];
+}
+def OMP_TaskYield : Directive<"taskyield"> {}
+def OMP_Barrier : Directive<"barrier"> {}
+def OMP_TaskWait : Directive<"taskwait"> {
+ let allowedClauses = [
+ VersionedClause<OMPC_Depend, 50>
+ ];
+}
+def OMP_TaskGroup : Directive<"taskgroup"> {
+ let allowedClauses = [
+ VersionedClause<OMPC_TaskReduction>,
+ VersionedClause<OMPC_Allocate>
+ ];
+}
+def OMP_Flush : Directive<"flush"> {
+ let allowedOnceClauses = [
+ VersionedClause<OMPC_AcqRel, 50>,
+ VersionedClause<OMPC_Acquire, 50>,
+ VersionedClause<OMPC_Release, 50>,
+ // TODO This should ne `none` instead. Comment carried over from
+ // OMPKinds.def.
+ VersionedClause<OMPC_Flush>
+ ];
+}
+def OMP_Ordered : Directive<"ordered"> {
+ let allowedClauses = [
+ VersionedClause<OMPC_Threads>,
+ VersionedClause<OMPC_Simd>,
+ VersionedClause<OMPC_Depend>
+ ];
+}
+def OMP_Atomic : Directive<"atomic"> {
+ let allowedClauses = [
+ VersionedClause<OMPC_Read>,
+ VersionedClause<OMPC_Write>,
+ VersionedClause<OMPC_Update>,
+ VersionedClause<OMPC_Capture>,
+ ];
+ let allowedOnceClauses = [
+ VersionedClause<OMPC_SeqCst>,
+ VersionedClause<OMPC_AcqRel, 50>,
+ VersionedClause<OMPC_Acquire, 50>,
+ VersionedClause<OMPC_Release, 50>,
+ VersionedClause<OMPC_Relaxed, 50>,
+ VersionedClause<OMPC_Hint, 50>
+ ];
+}
+def OMP_Target : Directive<"target"> {
+ let allowedClauses = [
+ VersionedClause<OMPC_If>,
+ VersionedClause<OMPC_Map>,
+ VersionedClause<OMPC_Private>,
+ VersionedClause<OMPC_Depend>,
+ VersionedClause<OMPC_FirstPrivate>,
+ VersionedClause<OMPC_IsDevicePtr>,
+ VersionedClause<OMPC_Reduction>,
+ VersionedClause<OMPC_Allocate>,
+ VersionedClause<OMPC_UsesAllocators, 50>
+ ];
+ let allowedOnceClauses = [
+ VersionedClause<OMPC_Device>,
+ VersionedClause<OMPC_DefaultMap>,
+ VersionedClause<OMPC_NoWait>
+ ];
+}
+def OMP_Teams : Directive<"teams"> {
+ let allowedClauses = [
+ VersionedClause<OMPC_Private>,
+ VersionedClause<OMPC_FirstPrivate>,
+ VersionedClause<OMPC_Shared>,
+ VersionedClause<OMPC_Reduction>,
+ VersionedClause<OMPC_Allocate>
+ ];
+ let allowedOnceClauses = [
+ VersionedClause<OMPC_Default>,
+ VersionedClause<OMPC_NumTeams>,
+ VersionedClause<OMPC_ThreadLimit>
+ ];
+}
+def OMP_Cancel : Directive<"cancel"> {
+ let allowedClauses = [
+ VersionedClause<OMPC_If>
+ ];
+}
+def OMP_Requires : Directive<"requires"> {
+ let allowedClauses = [
+ VersionedClause<OMPC_UnifiedAddress>,
+ VersionedClause<OMPC_UnifiedSharedMemory>,
+ VersionedClause<OMPC_ReverseOffload>,
+ VersionedClause<OMPC_DynamicAllocators>,
+ VersionedClause<OMPC_AtomicDefaultMemOrder>
+ ];
+}
+def OMP_TargetData : Directive<"target data"> {
+ let allowedClauses = [
+ VersionedClause<OMPC_UseDevicePtr>,
+ VersionedClause<OMPC_UseDeviceAddr, 50>
+ ];
+ let allowedOnceClauses = [
+ VersionedClause<OMPC_Device>,
+ VersionedClause<OMPC_If>
+ ];
+ let requiredClauses = [
+ VersionedClause<OMPC_Map>
+ ];
+}
+def OMP_TargetEnterData : Directive<"target enter data"> {
+ let allowedClauses = [
+ VersionedClause<OMPC_Depend>
+ ];
+ let allowedOnceClauses = [
+ VersionedClause<OMPC_If>,
+ VersionedClause<OMPC_Device>,
+ VersionedClause<OMPC_NoWait>
+ ];
+ let requiredClauses = [
+ VersionedClause<OMPC_Map>
+ ];
+}
+def OMP_TargetExitData : Directive<"target exit data"> {
+ let allowedClauses = [
+ VersionedClause<OMPC_Depend>
+ ];
+ let allowedOnceClauses = [
+ VersionedClause<OMPC_Device>,
+ VersionedClause<OMPC_If>,
+ VersionedClause<OMPC_NoWait>
+ ];
+ let requiredClauses = [
+ VersionedClause<OMPC_Map>
+ ];
+}
+def OMP_TargetParallel : Directive<"target parallel"> {
+ let allowedClauses = [
+ VersionedClause<OMPC_Map>,
+ VersionedClause<OMPC_NoWait>,
+ VersionedClause<OMPC_Depend>,
+ VersionedClause<OMPC_Private>,
+ VersionedClause<OMPC_FirstPrivate>,
+ VersionedClause<OMPC_Default>,
+ VersionedClause<OMPC_Shared>,
+ VersionedClause<OMPC_Reduction>,
+ VersionedClause<OMPC_IsDevicePtr>,
+ VersionedClause<OMPC_Allocate>,
+ VersionedClause<OMPC_UsesAllocators, 50>
+ ];
+ let allowedOnceClauses = [
+ VersionedClause<OMPC_DefaultMap>,
+ VersionedClause<OMPC_Device>,
+ VersionedClause<OMPC_If>,
+ VersionedClause<OMPC_NumThreads>,
+ VersionedClause<OMPC_ProcBind>
+ ];
+}
+def OMP_TargetParallelFor : Directive<"target parallel for"> {
+ let allowedClauses = [
+ VersionedClause<OMPC_If>,
+ VersionedClause<OMPC_Device>,
+ VersionedClause<OMPC_Map>,
+ VersionedClause<OMPC_Private>,
+ VersionedClause<OMPC_FirstPrivate>,
+ VersionedClause<OMPC_LastPrivate>,
+ VersionedClause<OMPC_NoWait>,
+ VersionedClause<OMPC_Depend>,
+ VersionedClause<OMPC_DefaultMap>,
+ VersionedClause<OMPC_NumThreads>,
+ VersionedClause<OMPC_Default>,
+ VersionedClause<OMPC_ProcBind>,
+ VersionedClause<OMPC_Shared>,
+ VersionedClause<OMPC_Reduction>,
+ VersionedClause<OMPC_Collapse>,
+ VersionedClause<OMPC_Schedule>,
+ VersionedClause<OMPC_Ordered>,
+ VersionedClause<OMPC_Linear>,
+ VersionedClause<OMPC_IsDevicePtr>,
+ VersionedClause<OMPC_Allocate>,
+ VersionedClause<OMPC_Order, 50>,
+ VersionedClause<OMPC_UsesAllocators, 50>
+ ];
+}
+def OMP_TargetParallelDo : Directive<"target parallel do"> {
+ let allowedClauses = [
+ VersionedClause<OMPC_Map>,
+ VersionedClause<OMPC_Private>,
+ VersionedClause<OMPC_FirstPrivate>,
+ VersionedClause<OMPC_LastPrivate>,
+ VersionedClause<OMPC_Depend>,
+ VersionedClause<OMPC_Shared>,
+ VersionedClause<OMPC_Reduction>,
+ VersionedClause<OMPC_Linear>,
+ VersionedClause<OMPC_IsDevicePtr>,
+ VersionedClause<OMPC_Allocator>,
+ VersionedClause<OMPC_Order>,
+ VersionedClause<OMPC_UsesAllocators>,
+ VersionedClause<OMPC_Default>,
+ VersionedClause<OMPC_Copyin>
+ ];
+ let allowedOnceClauses = [
+ VersionedClause<OMPC_If>,
+ VersionedClause<OMPC_NumThreads>,
+ VersionedClause<OMPC_ProcBind>,
+ VersionedClause<OMPC_Device>,
+ VersionedClause<OMPC_DefaultMap>,
+ VersionedClause<OMPC_Schedule>,
+ VersionedClause<OMPC_Collapse>,
+ VersionedClause<OMPC_Ordered>,
+ VersionedClause<OMPC_NoWait>
+ ];
+}
+def OMP_TargetUpdate : Directive<"target update"> {
+ let allowedClauses = [
+ VersionedClause<OMPC_If>,
+ VersionedClause<OMPC_Device>,
+ VersionedClause<OMPC_To>,
+ VersionedClause<OMPC_From>,
+ VersionedClause<OMPC_NoWait>,
+ VersionedClause<OMPC_Depend>
+ ];
+}
+def OMP_ParallelFor : Directive<"parallel for"> {
+ let allowedClauses = [
+ VersionedClause<OMPC_If>,
+ VersionedClause<OMPC_NumThreads>,
+ VersionedClause<OMPC_Default>,
+ VersionedClause<OMPC_ProcBind>,
+ VersionedClause<OMPC_Private>,
+ VersionedClause<OMPC_FirstPrivate>,
+ VersionedClause<OMPC_Shared>,
+ VersionedClause<OMPC_Reduction>,
+ VersionedClause<OMPC_Copyin>,
+ VersionedClause<OMPC_LastPrivate>,
+ VersionedClause<OMPC_Collapse>,
+ VersionedClause<OMPC_Schedule>,
+ VersionedClause<OMPC_Ordered>,
+ VersionedClause<OMPC_Linear>,
+ VersionedClause<OMPC_Allocate>,
+ VersionedClause<OMPC_Order, 50>
+ ];
+}
+def OMP_ParallelDo : Directive<"parallel do"> {
+ let allowedClauses = [
+ VersionedClause<OMPC_Default>,
+ VersionedClause<OMPC_Private>,
+ VersionedClause<OMPC_FirstPrivate>,
+ VersionedClause<OMPC_Shared>,
+ VersionedClause<OMPC_Reduction>,
+ VersionedClause<OMPC_Copyin>,
+ VersionedClause<OMPC_LastPrivate>,
+ VersionedClause<OMPC_Linear>
+ ];
+ let allowedOnceClauses = [
+ VersionedClause<OMPC_If>,
+ VersionedClause<OMPC_NumThreads>,
+ VersionedClause<OMPC_ProcBind>,
+ VersionedClause<OMPC_Schedule>,
+ VersionedClause<OMPC_Ordered>,
+ VersionedClause<OMPC_Collapse>
+ ];
+}
+def OMP_ParallelForSimd : Directive<"parallel for simd"> {
+ let allowedClauses = [
+ VersionedClause<OMPC_If>,
+ VersionedClause<OMPC_NumThreads>,
+ VersionedClause<OMPC_Default>,
+ VersionedClause<OMPC_ProcBind>,
+ VersionedClause<OMPC_Private>,
+ VersionedClause<OMPC_FirstPrivate>,
+ VersionedClause<OMPC_Shared>,
+ VersionedClause<OMPC_Reduction>,
+ VersionedClause<OMPC_Copyin>,
+ VersionedClause<OMPC_LastPrivate>,
+ VersionedClause<OMPC_Collapse>,
+ VersionedClause<OMPC_Schedule>,
+ VersionedClause<OMPC_SafeLen>,
+ VersionedClause<OMPC_SimdLen>,
+ VersionedClause<OMPC_Linear>,
+ VersionedClause<OMPC_Aligned>,
+ VersionedClause<OMPC_Ordered>,
+ VersionedClause<OMPC_Allocate>,
+ VersionedClause<OMPC_NonTemporal, 50>,
+ VersionedClause<OMPC_Order, 50>
+ ];
+}
+def OMP_ParallelDoSimd : Directive<"parallel do simd"> {
+ let allowedClauses = [
+ VersionedClause<OMPC_Default>,
+ VersionedClause<OMPC_Private>,
+ VersionedClause<OMPC_FirstPrivate>,
+ VersionedClause<OMPC_Shared>,
+ VersionedClause<OMPC_Reduction>,
+ VersionedClause<OMPC_Copyin>,
+ VersionedClause<OMPC_LastPrivate>,
+ VersionedClause<OMPC_Linear>,
+ VersionedClause<OMPC_Aligned>,
+ VersionedClause<OMPC_Allocate>,
+ VersionedClause<OMPC_NonTemporal>,
+ VersionedClause<OMPC_Order>
+ ];
+ let allowedOnceClauses = [
+ VersionedClause<OMPC_If>,
+ VersionedClause<OMPC_NumThreads>,
+ VersionedClause<OMPC_ProcBind>,
+ VersionedClause<OMPC_Schedule>,
+ VersionedClause<OMPC_Ordered>,
+ VersionedClause<OMPC_Collapse>,
+ VersionedClause<OMPC_SafeLen>,
+ VersionedClause<OMPC_SimdLen>
+ ];
+}
+def OMP_ParallelMaster : Directive<"parallel master"> {
+ let allowedClauses = [
+ VersionedClause<OMPC_If>,
+ VersionedClause<OMPC_NumThreads>,
+ VersionedClause<OMPC_Default>,
+ VersionedClause<OMPC_Private>,
+ VersionedClause<OMPC_FirstPrivate>,
+ VersionedClause<OMPC_Shared>,
+ VersionedClause<OMPC_Copyin>,
+ VersionedClause<OMPC_Reduction>,
+ VersionedClause<OMPC_ProcBind>,
+ VersionedClause<OMPC_Allocate>
+ ];
+}
+def OMP_ParallelSections : Directive<"parallel sections"> {
+ let allowedClauses = [
+ VersionedClause<OMPC_If>,
+ VersionedClause<OMPC_Default>,
+ VersionedClause<OMPC_ProcBind>,
+ VersionedClause<OMPC_Private>,
+ VersionedClause<OMPC_FirstPrivate>,
+ VersionedClause<OMPC_Shared>,
+ VersionedClause<OMPC_Reduction>,
+ VersionedClause<OMPC_Copyin>,
+ VersionedClause<OMPC_LastPrivate>,
+ VersionedClause<OMPC_Allocate>
+ ];
+ let allowedOnceClauses = [
+ VersionedClause<OMPC_NumThreads>
+ ];
+}
+def OMP_ForSimd : Directive<"for simd"> {
+ let allowedClauses = [
+ VersionedClause<OMPC_Private>,
+ VersionedClause<OMPC_FirstPrivate>,
+ VersionedClause<OMPC_LastPrivate>,
+ VersionedClause<OMPC_Reduction>,
+ VersionedClause<OMPC_Schedule>,
+ VersionedClause<OMPC_Collapse>,
+ VersionedClause<OMPC_NoWait>,
+ VersionedClause<OMPC_SafeLen>,
+ VersionedClause<OMPC_SimdLen>,
+ VersionedClause<OMPC_Linear>,
+ VersionedClause<OMPC_Aligned>,
+ VersionedClause<OMPC_Ordered>,
+ VersionedClause<OMPC_Allocate>,
+ VersionedClause<OMPC_If, 50>,
+ VersionedClause<OMPC_NonTemporal, 50>,
+ VersionedClause<OMPC_Order, 50>,
+ ];
+}
+def OMP_DoSimd : Directive<"do simd"> {
+ let allowedClauses = [
+ VersionedClause<OMPC_Aligned>,
+ VersionedClause<OMPC_Private>,
+ VersionedClause<OMPC_FirstPrivate>,
+ VersionedClause<OMPC_LastPrivate>,
+ VersionedClause<OMPC_Linear>,
+ VersionedClause<OMPC_Reduction>
+ ];
+ let allowedOnceClauses = [
+ VersionedClause<OMPC_Schedule>,
+ VersionedClause<OMPC_Collapse>,
+ VersionedClause<OMPC_Ordered>,
+ VersionedClause<OMPC_SafeLen>,
+ VersionedClause<OMPC_SimdLen>,
+ VersionedClause<OMPC_NoWait>
+ ];
+}
+def OMP_CancellationPoint : Directive<"cancellation point"> {}
+def OMP_DeclareReduction : Directive<"declare reduction"> {}
+def OMP_DeclareMapper : Directive<"declare mapper"> {
+ let allowedClauses = [
+ VersionedClause<OMPC_Map>
+ ];
+}
+def OMP_DeclareSimd : Directive<"declare simd"> {
+ let allowedClauses = [
+ VersionedClause<OMPC_Linear>,
+ VersionedClause<OMPC_Aligned>,
+ VersionedClause<OMPC_Uniform>
+ ];
+ let allowedOnceClauses = [
+ VersionedClause<OMPC_SimdLen>
+ ];
+ let allowedExclusiveClauses = [
+ VersionedClause<OMPC_Inbranch>,
+ VersionedClause<OMPC_Notinbranch>
+ ];
+}
+def OMP_TaskLoop : Directive<"taskloop"> {
+ let allowedClauses = [
+ VersionedClause<OMPC_Shared>,
+ VersionedClause<OMPC_Private>,
+ VersionedClause<OMPC_FirstPrivate>,
+ VersionedClause<OMPC_LastPrivate>,
+ VersionedClause<OMPC_Untied>,
+ VersionedClause<OMPC_Mergeable>,
+ VersionedClause<OMPC_NoGroup>,
+ VersionedClause<OMPC_Reduction>,
+ VersionedClause<OMPC_InReduction>,
+ VersionedClause<OMPC_Allocate>
+ ];
+ let allowedOnceClauses = [
+ VersionedClause<OMPC_Default>,
+ VersionedClause<OMPC_If>,
+ VersionedClause<OMPC_Collapse>,
+ VersionedClause<OMPC_Final>,
+ VersionedClause<OMPC_Priority>,
+ ];
+ let allowedExclusiveClauses = [
+ VersionedClause<OMPC_GrainSize>,
+ VersionedClause<OMPC_NumTasks>
+ ];
+}
+def OMP_TaskLoopSimd : Directive<"taskloop simd"> {
+ let allowedClauses = [
+ VersionedClause<OMPC_Aligned>,
+ VersionedClause<OMPC_Allocate>,
+ VersionedClause<OMPC_Default>,
+ VersionedClause<OMPC_FirstPrivate>,
+ VersionedClause<OMPC_InReduction>,
+ VersionedClause<OMPC_LastPrivate>,
+ VersionedClause<OMPC_Linear>,
+ VersionedClause<OMPC_Mergeable>,
+ VersionedClause<OMPC_NoGroup>,
+ VersionedClause<OMPC_NonTemporal, 50>,
+ VersionedClause<OMPC_Order, 50>,
+ VersionedClause<OMPC_Private>,
+ VersionedClause<OMPC_Reduction>,
+ VersionedClause<OMPC_Shared>,
+ VersionedClause<OMPC_Untied>
+ ];
+ let allowedOnceClauses = [
+ VersionedClause<OMPC_If>,
+ VersionedClause<OMPC_Collapse>,
+ VersionedClause<OMPC_SafeLen>,
+ VersionedClause<OMPC_SimdLen>,
+ VersionedClause<OMPC_Final>,
+ VersionedClause<OMPC_Priority>
+ ];
+ let allowedExclusiveClauses = [
+ VersionedClause<OMPC_GrainSize>,
+ VersionedClause<OMPC_NumTasks>
+ ];
+}
+def OMP_Distribute : Directive<"distribute"> {
+ let allowedClauses = [
+ VersionedClause<OMPC_Private>,
+ VersionedClause<OMPC_FirstPrivate>,
+ VersionedClause<OMPC_LastPrivate>,
+ VersionedClause<OMPC_Allocate>
+ ];
+ let allowedOnceClauses = [
+ VersionedClause<OMPC_Collapse>,
+ VersionedClause<OMPC_DistSchedule>
+ ];
+}
+def OMP_DeclareTarget : Directive<"declare target"> {
+ let allowedClauses = [
+ VersionedClause<OMPC_To>,
+ VersionedClause<OMPC_Link>
+ ];
+}
+def OMP_EndDeclareTarget : Directive<"end declare target"> {}
+def OMP_DistributeParallelFor : Directive<"distribute parallel for"> {
+ let allowedClauses = [
+ VersionedClause<OMPC_FirstPrivate>,
+ VersionedClause<OMPC_LastPrivate>,
+ VersionedClause<OMPC_Collapse>,
+ VersionedClause<OMPC_DistSchedule>,
+ VersionedClause<OMPC_If>,
+ VersionedClause<OMPC_NumThreads>,
+ VersionedClause<OMPC_Default>,
+ VersionedClause<OMPC_ProcBind>,
+ VersionedClause<OMPC_Private>,
+ VersionedClause<OMPC_Shared>,
+ VersionedClause<OMPC_Reduction>,
+ VersionedClause<OMPC_Copyin>,
+ VersionedClause<OMPC_Schedule>,
+ VersionedClause<OMPC_Allocate>,
+ VersionedClause<OMPC_Order, 50>
+ ];
+}
+def OMP_DistributeParallelDo : Directive<"distribute parallel do"> {
+ let allowedClauses = [
+ VersionedClause<OMPC_Private>,
+ VersionedClause<OMPC_FirstPrivate>,
+ VersionedClause<OMPC_LastPrivate>,
+ VersionedClause<OMPC_Allocate>,
+ VersionedClause<OMPC_Order>,
+ VersionedClause<OMPC_Default>,
+ VersionedClause<OMPC_Shared>,
+ VersionedClause<OMPC_Reduction>,
+ VersionedClause<OMPC_Copyin>,
+ VersionedClause<OMPC_Linear>
+ ];
+ let allowedOnceClauses = [
+ VersionedClause<OMPC_Collapse>,
+ VersionedClause<OMPC_DistSchedule>,
+ VersionedClause<OMPC_If>,
+ VersionedClause<OMPC_NumThreads>,
+ VersionedClause<OMPC_ProcBind>,
+ VersionedClause<OMPC_Schedule>,
+ VersionedClause<OMPC_Ordered>
+ ];
+}
+def OMP_DistributeParallelForSimd : Directive<"distribute parallel for simd"> {
+ let allowedClauses = [
+ VersionedClause<OMPC_FirstPrivate>,
+ VersionedClause<OMPC_LastPrivate>,
+ VersionedClause<OMPC_Collapse>,
+ VersionedClause<OMPC_DistSchedule>,
+ VersionedClause<OMPC_If>,
+ VersionedClause<OMPC_NumThreads>,
+ VersionedClause<OMPC_Default>,
+ VersionedClause<OMPC_ProcBind>,
+ VersionedClause<OMPC_Private>,
+ VersionedClause<OMPC_Shared>,
+ VersionedClause<OMPC_Reduction>,
+ VersionedClause<OMPC_Copyin>,
+ VersionedClause<OMPC_Schedule>,
+ VersionedClause<OMPC_Linear>,
+ VersionedClause<OMPC_Aligned>,
+ VersionedClause<OMPC_SafeLen>,
+ VersionedClause<OMPC_SimdLen>,
+ VersionedClause<OMPC_Allocate>,
+ VersionedClause<OMPC_NonTemporal, 50>,
+ VersionedClause<OMPC_Order, 50>
+ ];
+}
+def OMP_DistributeParallelDoSimd : Directive<"distribute parallel do simd"> {
+ let allowedClauses = [
+ VersionedClause<OMPC_FirstPrivate>,
+ VersionedClause<OMPC_LastPrivate>,
+ VersionedClause<OMPC_Collapse>,
+ VersionedClause<OMPC_DistSchedule>,
+ VersionedClause<OMPC_If>,
+ VersionedClause<OMPC_NumThreads>,
+ VersionedClause<OMPC_Default>,
+ VersionedClause<OMPC_ProcBind>,
+ VersionedClause<OMPC_Private>,
+ VersionedClause<OMPC_Shared>,
+ VersionedClause<OMPC_Reduction>,
+ VersionedClause<OMPC_Copyin>,
+ VersionedClause<OMPC_Schedule>,
+ VersionedClause<OMPC_Linear>,
+ VersionedClause<OMPC_Aligned>,
+ VersionedClause<OMPC_SafeLen>,
+ VersionedClause<OMPC_SimdLen>,
+ VersionedClause<OMPC_Allocate>,
+ VersionedClause<OMPC_NonTemporal>,
+ VersionedClause<OMPC_Order>
+ ];
+}
+def OMP_DistributeSimd : Directive<"distribute simd"> {
+ let allowedClauses = [
+ VersionedClause<OMPC_Aligned>,
+ VersionedClause<OMPC_Allocate>,
+ VersionedClause<OMPC_Copyin>,
+ VersionedClause<OMPC_Default>,
+ VersionedClause<OMPC_Linear>,
+ VersionedClause<OMPC_FirstPrivate>,
+ VersionedClause<OMPC_LastPrivate>,
+ VersionedClause<OMPC_NonTemporal, 50>,
+ VersionedClause<OMPC_Order, 50>,
+ VersionedClause<OMPC_Private>,
+ VersionedClause<OMPC_Reduction>
+ ];
+ let allowedOnceClauses = [
+ VersionedClause<OMPC_Collapse>,
+ VersionedClause<OMPC_DistSchedule>,
+ VersionedClause<OMPC_If, 50>,
+ VersionedClause<OMPC_NumThreads>,
+ VersionedClause<OMPC_Ordered>,
+ VersionedClause<OMPC_ProcBind>,
+ VersionedClause<OMPC_Schedule>,
+ VersionedClause<OMPC_SafeLen>,
+ VersionedClause<OMPC_SimdLen>
+ ];
+}
+
+def OMP_TargetParallelForSimd : Directive<"target parallel for simd"> {
+ let allowedClauses = [
+ VersionedClause<OMPC_If>,
+ VersionedClause<OMPC_Device>,
+ VersionedClause<OMPC_Map>,
+ VersionedClause<OMPC_Private>,
+ VersionedClause<OMPC_FirstPrivate>,
+ VersionedClause<OMPC_LastPrivate>,
+ VersionedClause<OMPC_NoWait>,
+ VersionedClause<OMPC_Depend>,
+ VersionedClause<OMPC_DefaultMap>,
+ VersionedClause<OMPC_NumThreads>,
+ VersionedClause<OMPC_Default>,
+ VersionedClause<OMPC_ProcBind>,
+ VersionedClause<OMPC_Shared>,
+ VersionedClause<OMPC_Reduction>,
+ VersionedClause<OMPC_Collapse>,
+ VersionedClause<OMPC_Schedule>,
+ VersionedClause<OMPC_Ordered>,
+ VersionedClause<OMPC_Linear>,
+ VersionedClause<OMPC_SafeLen>,
+ VersionedClause<OMPC_SimdLen>,
+ VersionedClause<OMPC_Aligned>,
+ VersionedClause<OMPC_IsDevicePtr>,
+ VersionedClause<OMPC_Allocate>,
+ VersionedClause<OMPC_NonTemporal, 50>,
+ VersionedClause<OMPC_Order, 50>,
+ VersionedClause<OMPC_UsesAllocators, 50>
+ ];
+}
+def OMP_TargetParallelDoSimd : Directive<"target parallel do simd"> {
+ let allowedClauses = [
+ VersionedClause<OMPC_If>,
+ VersionedClause<OMPC_Device>,
+ VersionedClause<OMPC_Map>,
+ VersionedClause<OMPC_Private>,
+ VersionedClause<OMPC_FirstPrivate>,
+ VersionedClause<OMPC_LastPrivate>,
+ VersionedClause<OMPC_NoWait>,
+ VersionedClause<OMPC_Depend>,
+ VersionedClause<OMPC_DefaultMap>,
+ VersionedClause<OMPC_NumThreads>,
+ VersionedClause<OMPC_Default>,
+ VersionedClause<OMPC_ProcBind>,
+ VersionedClause<OMPC_Shared>,
+ VersionedClause<OMPC_Reduction>,
+ VersionedClause<OMPC_Collapse>,
+ VersionedClause<OMPC_Schedule>,
+ VersionedClause<OMPC_Ordered>,
+ VersionedClause<OMPC_Linear>,
+ VersionedClause<OMPC_SafeLen>,
+ VersionedClause<OMPC_SimdLen>,
+ VersionedClause<OMPC_Aligned>,
+ VersionedClause<OMPC_IsDevicePtr>,
+ VersionedClause<OMPC_Allocate>,
+ VersionedClause<OMPC_NonTemporal>,
+ VersionedClause<OMPC_Order>,
+ VersionedClause<OMPC_UsesAllocators>
+ ];
+}
+def OMP_TargetSimd : Directive<"target simd"> {
+ let allowedClauses = [
+ VersionedClause<OMPC_Aligned>,
+ VersionedClause<OMPC_Allocate>,
+ VersionedClause<OMPC_Depend>,
+ VersionedClause<OMPC_FirstPrivate>,
+ VersionedClause<OMPC_IsDevicePtr>,
+ VersionedClause<OMPC_LastPrivate>,
+ VersionedClause<OMPC_Linear>,
+ VersionedClause<OMPC_Map>,
+ VersionedClause<OMPC_NonTemporal, 50>,
+ VersionedClause<OMPC_NoWait>,
+ VersionedClause<OMPC_Order, 50>,
+ VersionedClause<OMPC_Private>,
+ VersionedClause<OMPC_Reduction>,
+ VersionedClause<OMPC_Shared>,
+ VersionedClause<OMPC_UsesAllocators, 50>
+ ];
+ let allowedOnceClauses = [
+ VersionedClause<OMPC_Collapse>,
+ VersionedClause<OMPC_SafeLen>,
+ VersionedClause<OMPC_SimdLen>,
+ VersionedClause<OMPC_If>,
+ VersionedClause<OMPC_NumThreads>,
+ VersionedClause<OMPC_ProcBind>,
+ VersionedClause<OMPC_Device>,
+ VersionedClause<OMPC_DefaultMap>,
+ VersionedClause<OMPC_Schedule>
+ ];
+}
+def OMP_TeamsDistribute : Directive<"teams distribute"> {
+ let allowedClauses = [
+ VersionedClause<OMPC_Default>,
+ VersionedClause<OMPC_Private>,
+ VersionedClause<OMPC_FirstPrivate>,
+ VersionedClause<OMPC_Shared>,
+ VersionedClause<OMPC_Reduction>,
+ VersionedClause<OMPC_NumTeams>,
+ VersionedClause<OMPC_ThreadLimit>,
+ VersionedClause<OMPC_LastPrivate>,
+ VersionedClause<OMPC_Collapse>,
+ VersionedClause<OMPC_DistSchedule>,
+ VersionedClause<OMPC_Allocate>
+ ];
+}
+def OMP_TeamsDistributeSimd : Directive<"teams distribute simd"> {
+ let allowedClauses = [
+ VersionedClause<OMPC_Aligned>,
+ VersionedClause<OMPC_Allocate>,
+ VersionedClause<OMPC_FirstPrivate>,
+ VersionedClause<OMPC_LastPrivate>,
+ VersionedClause<OMPC_Linear>,
+ VersionedClause<OMPC_NonTemporal, 50>,
+ VersionedClause<OMPC_Order, 50>,
+ VersionedClause<OMPC_Private>,
+ VersionedClause<OMPC_Reduction>,
+ VersionedClause<OMPC_Shared>
+ ];
+ let allowedOnceClauses = [
+ VersionedClause<OMPC_Collapse>,
+ VersionedClause<OMPC_Default>,
+ VersionedClause<OMPC_DistSchedule>,
+ VersionedClause<OMPC_If, 50>,
+ VersionedClause<OMPC_NumTeams>,
+ VersionedClause<OMPC_SafeLen>,
+ VersionedClause<OMPC_SimdLen>,
+ VersionedClause<OMPC_ThreadLimit>
+ ];
+}
+
+def OMP_TeamsDistributeParallelForSimd :
+ Directive<"teams distribute parallel for simd"> {
+ let allowedClauses = [
+ VersionedClause<OMPC_FirstPrivate>,
+ VersionedClause<OMPC_LastPrivate>,
+ VersionedClause<OMPC_Collapse>,
+ VersionedClause<OMPC_DistSchedule>,
+ VersionedClause<OMPC_If>,
+ VersionedClause<OMPC_NumThreads>,
+ VersionedClause<OMPC_Default>,
+ VersionedClause<OMPC_ProcBind>,
+ VersionedClause<OMPC_Private>,
+ VersionedClause<OMPC_Shared>,
+ VersionedClause<OMPC_Reduction>,
+ VersionedClause<OMPC_Schedule>,
+ VersionedClause<OMPC_Linear>,
+ VersionedClause<OMPC_Aligned>,
+ VersionedClause<OMPC_SafeLen>,
+ VersionedClause<OMPC_SimdLen>,
+ VersionedClause<OMPC_NumTeams>,
+ VersionedClause<OMPC_ThreadLimit>,
+ VersionedClause<OMPC_Allocate>,
+ VersionedClause<OMPC_NonTemporal, 50>,
+ VersionedClause<OMPC_Order, 50>
+ ];
+}
+def OMP_TeamsDistributeParallelDoSimd :
+ Directive<"teams distribute parallel do simd"> {
+ let allowedClauses = [
+ VersionedClause<OMPC_Private>,
+ VersionedClause<OMPC_FirstPrivate>,
+ VersionedClause<OMPC_LastPrivate>,
+ VersionedClause<OMPC_Allocate>,
+ VersionedClause<OMPC_Shared>,
+ VersionedClause<OMPC_Reduction>,
+ VersionedClause<OMPC_Linear>,
+ VersionedClause<OMPC_Order>,
+ VersionedClause<OMPC_Aligned>,
+ VersionedClause<OMPC_NonTemporal>
+ ];
+ let allowedOnceClauses = [
+ VersionedClause<OMPC_Default>,
+ VersionedClause<OMPC_NumTeams>,
+ VersionedClause<OMPC_ThreadLimit>,
+ VersionedClause<OMPC_Collapse>,
+ VersionedClause<OMPC_DistSchedule>,
+ VersionedClause<OMPC_NumThreads>,
+ VersionedClause<OMPC_ProcBind>,
+ VersionedClause<OMPC_Schedule>,
+ VersionedClause<OMPC_SafeLen>,
+ VersionedClause<OMPC_SimdLen>,
+ VersionedClause<OMPC_If>,
+ ];
+}
+def OMP_TeamsDistributeParallelFor :
+ Directive<"teams distribute parallel for"> {
+ let allowedClauses = [
+ VersionedClause<OMPC_FirstPrivate>,
+ VersionedClause<OMPC_LastPrivate>,
+ VersionedClause<OMPC_Collapse>,
+ VersionedClause<OMPC_DistSchedule>,
+ VersionedClause<OMPC_If>,
+ VersionedClause<OMPC_NumThreads>,
+ VersionedClause<OMPC_Default>,
+ VersionedClause<OMPC_ProcBind>,
+ VersionedClause<OMPC_Private>,
+ VersionedClause<OMPC_Shared>,
+ VersionedClause<OMPC_Reduction>,
+ VersionedClause<OMPC_Schedule>,
+ VersionedClause<OMPC_NumTeams>,
+ VersionedClause<OMPC_ThreadLimit>,
+ VersionedClause<OMPC_Copyin>,
+ VersionedClause<OMPC_Allocate>,
+ VersionedClause<OMPC_Order, 50>
+ ];
+}
+def OMP_TeamsDistributeParallelDo :
+ Directive<"teams distribute parallel do"> {
+ let allowedClauses = [
+ VersionedClause<OMPC_Private>,
+ VersionedClause<OMPC_FirstPrivate>,
+ VersionedClause<OMPC_LastPrivate>,
+ VersionedClause<OMPC_Shared>,
+ VersionedClause<OMPC_Reduction>,
+ VersionedClause<OMPC_Allocate>,
+ VersionedClause<OMPC_Copyin>,
+ VersionedClause<OMPC_Linear>
+ ];
+let allowedOnceClauses = [
+ VersionedClause<OMPC_NumTeams>,
+ VersionedClause<OMPC_ThreadLimit>,
+ VersionedClause<OMPC_Default>,
+ VersionedClause<OMPC_Collapse>,
+ VersionedClause<OMPC_DistSchedule>,
+ VersionedClause<OMPC_Ordered>,
+ VersionedClause<OMPC_Order>,
+ VersionedClause<OMPC_If>,
+ VersionedClause<OMPC_NumThreads>,
+ VersionedClause<OMPC_ProcBind>,
+ VersionedClause<OMPC_Schedule>
+ ];
+}
+def OMP_TargetTeams : Directive<"target teams"> {
+ let allowedClauses = [
+ VersionedClause<OMPC_If>,
+ VersionedClause<OMPC_Map>,
+ VersionedClause<OMPC_Private>,
+ VersionedClause<OMPC_Depend>,
+ VersionedClause<OMPC_FirstPrivate>,
+ VersionedClause<OMPC_IsDevicePtr>,
+ VersionedClause<OMPC_Reduction>,
+ VersionedClause<OMPC_Allocate>,
+ VersionedClause<OMPC_UsesAllocators, 50>,
+ VersionedClause<OMPC_Shared>
+ ];
+
+ let allowedOnceClauses = [
+ VersionedClause<OMPC_Device>,
+ VersionedClause<OMPC_NoWait>,
+ VersionedClause<OMPC_DefaultMap>,
+ VersionedClause<OMPC_Default>,
+ VersionedClause<OMPC_NumTeams>,
+ VersionedClause<OMPC_ThreadLimit>
+ ];
+}
+def OMP_TargetTeamsDistribute : Directive<"target teams distribute"> {
+ let allowedClauses = [
+ VersionedClause<OMPC_If>,
+ VersionedClause<OMPC_Map>,
+ VersionedClause<OMPC_Private>,
+ VersionedClause<OMPC_Depend>,
+ VersionedClause<OMPC_FirstPrivate>,
+ VersionedClause<OMPC_IsDevicePtr>,
+ VersionedClause<OMPC_Reduction>,
+ VersionedClause<OMPC_Allocate>,
+ VersionedClause<OMPC_UsesAllocators, 50>,
+ VersionedClause<OMPC_Shared>,
+ VersionedClause<OMPC_LastPrivate>
+ ];
+ let allowedOnceClauses = [
+ VersionedClause<OMPC_Device>,
+ VersionedClause<OMPC_NoWait>,
+ VersionedClause<OMPC_DefaultMap>,
+ VersionedClause<OMPC_Default>,
+ VersionedClause<OMPC_NumTeams>,
+ VersionedClause<OMPC_ThreadLimit>,
+ VersionedClause<OMPC_Collapse>,
+ VersionedClause<OMPC_DistSchedule>
+ ];
+}
+
+def OMP_TargetTeamsDistributeParallelFor :
+ Directive<"target teams distribute parallel for"> {
+ let allowedClauses = [
+ VersionedClause<OMPC_If>,
+ VersionedClause<OMPC_Device>,
+ VersionedClause<OMPC_Map>,
+ VersionedClause<OMPC_Private>,
+ VersionedClause<OMPC_NoWait>,
+ VersionedClause<OMPC_Depend>,
+ VersionedClause<OMPC_DefaultMap>,
+ VersionedClause<OMPC_FirstPrivate>,
+ VersionedClause<OMPC_IsDevicePtr>,
+ VersionedClause<OMPC_Default>,
+ VersionedClause<OMPC_Shared>,
+ VersionedClause<OMPC_Reduction>,
+ VersionedClause<OMPC_NumTeams>,
+ VersionedClause<OMPC_ThreadLimit>,
+ VersionedClause<OMPC_LastPrivate>,
+ VersionedClause<OMPC_Collapse>,
+ VersionedClause<OMPC_DistSchedule>,
+ VersionedClause<OMPC_NumThreads>,
+ VersionedClause<OMPC_ProcBind>,
+ VersionedClause<OMPC_Schedule>,
+ VersionedClause<OMPC_Allocate>,
+ VersionedClause<OMPC_Order, 50>,
+ VersionedClause<OMPC_UsesAllocators, 50>
+ ];
+}
+def OMP_TargetTeamsDistributeParallelDo :
+ Directive<"target teams distribute parallel do"> {
+ let allowedClauses = [
+ VersionedClause<OMPC_If>,
+ VersionedClause<OMPC_Map>,
+ VersionedClause<OMPC_Private>,
+ VersionedClause<OMPC_Depend>,
+ VersionedClause<OMPC_FirstPrivate>,
+ VersionedClause<OMPC_IsDevicePtr>,
+ VersionedClause<OMPC_Reduction>,
+ VersionedClause<OMPC_Allocate>,
+ VersionedClause<OMPC_UsesAllocators>,
+ VersionedClause<OMPC_Shared>,
+ VersionedClause<OMPC_LastPrivate>,
+ VersionedClause<OMPC_Copyin>,
+ VersionedClause<OMPC_Linear>,
+ VersionedClause<OMPC_Ordered>,
+ VersionedClause<OMPC_Order>
+ ];
+ let allowedOnceClauses = [
+ VersionedClause<OMPC_Device>,
+ VersionedClause<OMPC_DefaultMap>,
+ VersionedClause<OMPC_NoWait>,
+ VersionedClause<OMPC_Default>,
+ VersionedClause<OMPC_NumTeams>,
+ VersionedClause<OMPC_ThreadLimit>,
+ VersionedClause<OMPC_Collapse>,
+ VersionedClause<OMPC_DistSchedule>,
+ VersionedClause<OMPC_NumThreads>,
+ VersionedClause<OMPC_ProcBind>,
+ VersionedClause<OMPC_Schedule>,
+ ];
+}
+def OMP_TargetTeamsDistributeParallelForSimd :
+ Directive<"target teams distribute parallel for simd"> {
+ let allowedClauses = [
+ VersionedClause<OMPC_If>,
+ VersionedClause<OMPC_Device>,
+ VersionedClause<OMPC_Map>,
+ VersionedClause<OMPC_Private>,
+ VersionedClause<OMPC_NoWait>,
+ VersionedClause<OMPC_Depend>,
+ VersionedClause<OMPC_DefaultMap>,
+ VersionedClause<OMPC_FirstPrivate>,
+ VersionedClause<OMPC_IsDevicePtr>,
+ VersionedClause<OMPC_Default>,
+ VersionedClause<OMPC_Shared>,
+ VersionedClause<OMPC_Reduction>,
+ VersionedClause<OMPC_NumTeams>,
+ VersionedClause<OMPC_ThreadLimit>,
+ VersionedClause<OMPC_LastPrivate>,
+ VersionedClause<OMPC_Collapse>,
+ VersionedClause<OMPC_DistSchedule>,
+ VersionedClause<OMPC_NumThreads>,
+ VersionedClause<OMPC_ProcBind>,
+ VersionedClause<OMPC_Schedule>,
+ VersionedClause<OMPC_Linear>,
+ VersionedClause<OMPC_Aligned>,
+ VersionedClause<OMPC_SafeLen>,
+ VersionedClause<OMPC_SimdLen>,
+ VersionedClause<OMPC_Allocate>,
+ VersionedClause<OMPC_NonTemporal, 50>,
+ VersionedClause<OMPC_Order, 50>,
+ VersionedClause<OMPC_UsesAllocators, 50>
+ ];
+}
+def OMP_TargetTeamsDistributeParallelDoSimd :
+ Directive<"target teams distribute parallel do simd"> {
+ let allowedClauses = [
+ VersionedClause<OMPC_Map>,
+ VersionedClause<OMPC_Private>,
+ VersionedClause<OMPC_Depend>,
+ VersionedClause<OMPC_FirstPrivate>,
+ VersionedClause<OMPC_IsDevicePtr>,
+ VersionedClause<OMPC_Reduction>,
+ VersionedClause<OMPC_Allocate>,
+ VersionedClause<OMPC_UsesAllocators>,
+ VersionedClause<OMPC_Shared>,
+ VersionedClause<OMPC_LastPrivate>,
+ VersionedClause<OMPC_Copyin>,
+ VersionedClause<OMPC_Linear>,
+ VersionedClause<OMPC_Ordered>,
+ VersionedClause<OMPC_Order>,
+ VersionedClause<OMPC_Aligned>,
+ VersionedClause<OMPC_NonTemporal>
+ ];
+ let allowedOnceClauses = [
+ VersionedClause<OMPC_If>,
+ VersionedClause<OMPC_Device>,
+ VersionedClause<OMPC_NoWait>,
+ VersionedClause<OMPC_DefaultMap>,
+ VersionedClause<OMPC_Default>,
+ VersionedClause<OMPC_NumTeams>,
+ VersionedClause<OMPC_ThreadLimit>,
+ VersionedClause<OMPC_Collapse>,
+ VersionedClause<OMPC_DistSchedule>,
+ VersionedClause<OMPC_NumThreads>,
+ VersionedClause<OMPC_ProcBind>,
+ VersionedClause<OMPC_Schedule>,
+ VersionedClause<OMPC_SafeLen>,
+ VersionedClause<OMPC_SimdLen>
+ ];
+}
+def OMP_TargetTeamsDistributeSimd :
+ Directive<"target teams distribute simd"> {
+ let allowedClauses = [
+ VersionedClause<OMPC_Aligned>,
+ VersionedClause<OMPC_Allocate>,
+ VersionedClause<OMPC_Depend>,
+ VersionedClause<OMPC_FirstPrivate>,
+ VersionedClause<OMPC_If>,
+ VersionedClause<OMPC_IsDevicePtr>,
+ VersionedClause<OMPC_LastPrivate>,
+ VersionedClause<OMPC_Linear>,
+ VersionedClause<OMPC_Map>,
+ VersionedClause<OMPC_NonTemporal, 50>,
+ VersionedClause<OMPC_Order, 50>,
+ VersionedClause<OMPC_Private>,
+ VersionedClause<OMPC_Reduction>,
+ VersionedClause<OMPC_Shared>,
+ VersionedClause<OMPC_UsesAllocators, 50>
+ ];
+ let allowedOnceClauses = [
+ VersionedClause<OMPC_Device>,
+ VersionedClause<OMPC_DefaultMap>,
+ VersionedClause<OMPC_NoWait>,
+ VersionedClause<OMPC_NumTeams>,
+ VersionedClause<OMPC_ThreadLimit>,
+ VersionedClause<OMPC_Collapse>,
+ VersionedClause<OMPC_DistSchedule>,
+ VersionedClause<OMPC_SafeLen>,
+ VersionedClause<OMPC_SimdLen>,
+ ];
+}
+def OMP_Allocate : Directive<"allocate"> {
+ let allowedClauses = [
+ VersionedClause<OMPC_Allocator>
+ ];
+}
+def OMP_DeclareVariant : Directive<"declare variant"> {
+ let allowedClauses = [
+ VersionedClause<OMPC_Match>
+ ];
+}
+def OMP_MasterTaskloop : Directive<"master taskloop"> {
+ let allowedClauses = [
+ VersionedClause<OMPC_If>,
+ VersionedClause<OMPC_Shared>,
+ VersionedClause<OMPC_Private>,
+ VersionedClause<OMPC_FirstPrivate>,
+ VersionedClause<OMPC_LastPrivate>,
+ VersionedClause<OMPC_Default>,
+ VersionedClause<OMPC_Collapse>,
+ VersionedClause<OMPC_Final>,
+ VersionedClause<OMPC_Untied>,
+ VersionedClause<OMPC_Mergeable>,
+ VersionedClause<OMPC_Priority>,
+ VersionedClause<OMPC_GrainSize>,
+ VersionedClause<OMPC_NoGroup>,
+ VersionedClause<OMPC_NumTasks>,
+ VersionedClause<OMPC_Reduction>,
+ VersionedClause<OMPC_InReduction>,
+ VersionedClause<OMPC_Allocate>
+ ];
+}
+def OMP_ParallelMasterTaskloop :
+ Directive<"parallel master taskloop"> {
+ let allowedClauses = [
+ VersionedClause<OMPC_If>,
+ VersionedClause<OMPC_Shared>,
+ VersionedClause<OMPC_Private>,
+ VersionedClause<OMPC_FirstPrivate>,
+ VersionedClause<OMPC_LastPrivate>,
+ VersionedClause<OMPC_Default>,
+ VersionedClause<OMPC_Collapse>,
+ VersionedClause<OMPC_Final>,
+ VersionedClause<OMPC_Untied>,
+ VersionedClause<OMPC_Mergeable>,
+ VersionedClause<OMPC_Priority>,
+ VersionedClause<OMPC_GrainSize>,
+ VersionedClause<OMPC_NoGroup>,
+ VersionedClause<OMPC_NumTasks>,
+ VersionedClause<OMPC_Reduction>,
+ VersionedClause<OMPC_Allocate>,
+ VersionedClause<OMPC_NumThreads>,
+ VersionedClause<OMPC_ProcBind>,
+ VersionedClause<OMPC_Copyin>
+ ];
+}
+def OMP_MasterTaskloopSimd : Directive<"master taskloop simd"> {
+ let allowedClauses = [
+ VersionedClause<OMPC_If>,
+ VersionedClause<OMPC_Shared>,
+ VersionedClause<OMPC_Private>,
+ VersionedClause<OMPC_FirstPrivate>,
+ VersionedClause<OMPC_LastPrivate>,
+ VersionedClause<OMPC_Default>,
+ VersionedClause<OMPC_Collapse>,
+ VersionedClause<OMPC_Final>,
+ VersionedClause<OMPC_Untied>,
+ VersionedClause<OMPC_Mergeable>,
+ VersionedClause<OMPC_Priority>,
+ VersionedClause<OMPC_Linear>,
+ VersionedClause<OMPC_Aligned>,
+ VersionedClause<OMPC_SafeLen>,
+ VersionedClause<OMPC_SimdLen>,
+ VersionedClause<OMPC_GrainSize>,
+ VersionedClause<OMPC_NoGroup>,
+ VersionedClause<OMPC_NumTasks>,
+ VersionedClause<OMPC_Reduction>,
+ VersionedClause<OMPC_InReduction>,
+ VersionedClause<OMPC_Allocate>,
+ VersionedClause<OMPC_NonTemporal, 50>,
+ VersionedClause<OMPC_Order, 50>
+ ];
+}
+def OMP_ParallelMasterTaskloopSimd :
+ Directive<"parallel master taskloop simd"> {
+ let allowedClauses = [
+ VersionedClause<OMPC_If>,
+ VersionedClause<OMPC_Shared>,
+ VersionedClause<OMPC_Private>,
+ VersionedClause<OMPC_FirstPrivate>,
+ VersionedClause<OMPC_LastPrivate>,
+ VersionedClause<OMPC_Default>,
+ VersionedClause<OMPC_Collapse>,
+ VersionedClause<OMPC_Final>,
+ VersionedClause<OMPC_Untied>,
+ VersionedClause<OMPC_Mergeable>,
+ VersionedClause<OMPC_Priority>,
+ VersionedClause<OMPC_GrainSize>,
+ VersionedClause<OMPC_NoGroup>,
+ VersionedClause<OMPC_NumTasks>,
+ VersionedClause<OMPC_Reduction>,
+ VersionedClause<OMPC_Allocate>,
+ VersionedClause<OMPC_NumThreads>,
+ VersionedClause<OMPC_ProcBind>,
+ VersionedClause<OMPC_Copyin>,
+ VersionedClause<OMPC_Linear>,
+ VersionedClause<OMPC_Aligned>,
+ VersionedClause<OMPC_SafeLen>,
+ VersionedClause<OMPC_SimdLen>,
+ VersionedClause<OMPC_NonTemporal, 50>,
+ VersionedClause<OMPC_Order, 50>
+ ];
+}
+def OMP_Depobj : Directive<"depobj"> {
+ let allowedClauses = [
+ VersionedClause<OMPC_Depend, 50>,
+ VersionedClause<OMPC_Destroy, 50>,
+ VersionedClause<OMPC_Update, 50>,
+ // TODO This should ne `none` instead. Comment carried over from
+ // OMPKinds.def.
+ VersionedClause<OMPC_Depobj, 50>
+ ];
+}
+def OMP_Scan : Directive<"scan"> {
+ let allowedClauses = [
+ VersionedClause<OMPC_Inclusive, 50>,
+ VersionedClause<OMPC_Exclusive, 50>
+ ];
+}
+def OMP_Assumes : Directive<"assumes"> {}
+def OMP_BeginAssumes : Directive<"begin assumes"> {}
+def OMP_EndAssumes : Directive<"end assumes"> {}
+def OMP_BeginDeclareVariant : Directive<"begin declare variant"> {}
+def OMP_EndDeclareVariant : Directive<"end declare variant"> {}
+def OMP_ParallelWorkshare : Directive<"parallel workshare"> {
+ let allowedClauses = [
+ VersionedClause<OMPC_Allocate>,
+ VersionedClause<OMPC_Copyin>,
+ VersionedClause<OMPC_Default>,
+ VersionedClause<OMPC_FirstPrivate>,
+ VersionedClause<OMPC_Private>,
+ VersionedClause<OMPC_Reduction>,
+ VersionedClause<OMPC_Shared>
+ ];
+ let allowedOnceClauses = [
+ VersionedClause<OMPC_If>,
+ VersionedClause<OMPC_NumThreads>,
+ VersionedClause<OMPC_ProcBind>
+ ];
+}
+def OMP_Workshare : Directive<"workshare"> {}
+def OMP_EndDo : Directive<"end do"> {}
+def OMP_EndDoSimd : Directive<"end do simd"> {}
+def OMP_EndSections : Directive<"end sections"> {
+ let allowedOnceClauses = [
+ VersionedClause<OMPC_NoWait>
+ ];
+}
+def OMP_EndSingle : Directive<"end single"> {
+ let allowedClauses = [
+ VersionedClause<OMPC_CopyPrivate>
+ ];
+ let allowedOnceClauses = [
+ VersionedClause<OMPC_NoWait>
+ ];
+}
+def OMP_EndWorkshare : Directive<"end workshare"> {
+ let allowedClauses = [
+ VersionedClause<OMPC_NoWait>
+ ];
+}
+def OMP_Unknown : Directive<"unknown"> {
+ let isDefault = true;
+}
diff --git a/linux-x64/clang/include/llvm/Frontend/OpenMP/OMPConstants.h b/linux-x64/clang/include/llvm/Frontend/OpenMP/OMPConstants.h
new file mode 100644
index 0000000..36ce3fc
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Frontend/OpenMP/OMPConstants.h
@@ -0,0 +1,114 @@
+//===- OMPConstants.h - OpenMP related constants and helpers ------ C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+/// \file
+///
+/// This file defines constans and helpers used when dealing with OpenMP.
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_OPENMP_CONSTANTS_H
+#define LLVM_OPENMP_CONSTANTS_H
+
+#include "llvm/ADT/BitmaskEnum.h"
+
+#include "llvm/ADT/StringRef.h"
+#include "llvm/Frontend/OpenMP/OMP.h.inc"
+
+namespace llvm {
+class Type;
+class Module;
+class ArrayType;
+class StructType;
+class PointerType;
+class StringRef;
+class FunctionType;
+
+namespace omp {
+LLVM_ENABLE_BITMASK_ENUMS_IN_NAMESPACE();
+
+/// IDs for all Internal Control Variables (ICVs).
+enum class InternalControlVar {
+#define ICV_DATA_ENV(Enum, ...) Enum,
+#include "llvm/Frontend/OpenMP/OMPKinds.def"
+};
+
+#define ICV_DATA_ENV(Enum, ...) \
+ constexpr auto Enum = omp::InternalControlVar::Enum;
+#include "llvm/Frontend/OpenMP/OMPKinds.def"
+
+enum class ICVInitValue {
+#define ICV_INIT_VALUE(Enum, Name) Enum,
+#include "llvm/Frontend/OpenMP/OMPKinds.def"
+};
+
+#define ICV_INIT_VALUE(Enum, Name) \
+ constexpr auto Enum = omp::ICVInitValue::Enum;
+#include "llvm/Frontend/OpenMP/OMPKinds.def"
+
+/// IDs for all omp runtime library (RTL) functions.
+enum class RuntimeFunction {
+#define OMP_RTL(Enum, ...) Enum,
+#include "llvm/Frontend/OpenMP/OMPKinds.def"
+};
+
+#define OMP_RTL(Enum, ...) constexpr auto Enum = omp::RuntimeFunction::Enum;
+#include "llvm/Frontend/OpenMP/OMPKinds.def"
+
+/// IDs for the different default kinds.
+enum class DefaultKind {
+#define OMP_DEFAULT_KIND(Enum, Str) Enum,
+#include "llvm/Frontend/OpenMP/OMPKinds.def"
+};
+
+#define OMP_DEFAULT_KIND(Enum, ...) \
+ constexpr auto Enum = omp::DefaultKind::Enum;
+#include "llvm/Frontend/OpenMP/OMPKinds.def"
+
+/// IDs for all omp runtime library ident_t flag encodings (see
+/// their defintion in openmp/runtime/src/kmp.h).
+enum class IdentFlag {
+#define OMP_IDENT_FLAG(Enum, Str, Value) Enum = Value,
+#include "llvm/Frontend/OpenMP/OMPKinds.def"
+ LLVM_MARK_AS_BITMASK_ENUM(0x7FFFFFFF)
+};
+
+#define OMP_IDENT_FLAG(Enum, ...) constexpr auto Enum = omp::IdentFlag::Enum;
+#include "llvm/Frontend/OpenMP/OMPKinds.def"
+
+/// Helper to describe assume clauses.
+struct AssumptionClauseMappingInfo {
+ /// The identifier describing the (beginning of the) clause.
+ llvm::StringLiteral Identifier;
+ /// Flag to determine if the identifier is a full name or the start of a name.
+ bool StartsWith;
+ /// Flag to determine if a directive lists follows.
+ bool HasDirectiveList;
+ /// Flag to determine if an expression follows.
+ bool HasExpression;
+};
+
+/// All known assume clauses.
+static constexpr AssumptionClauseMappingInfo AssumptionClauseMappings[] = {
+#define OMP_ASSUME_CLAUSE(Identifier, StartsWith, HasDirectiveList, \
+ HasExpression) \
+ {Identifier, StartsWith, HasDirectiveList, HasExpression},
+#include "llvm/Frontend/OpenMP/OMPKinds.def"
+};
+
+inline std::string getAllAssumeClauseOptions() {
+ std::string S;
+ for (const AssumptionClauseMappingInfo &ACMI : AssumptionClauseMappings)
+ S += (S.empty() ? "'" : "', '") + ACMI.Identifier.str();
+ return S + "'";
+}
+
+} // end namespace omp
+
+} // end namespace llvm
+
+#endif // LLVM_OPENMP_CONSTANTS_H
diff --git a/linux-x64/clang/include/llvm/Frontend/OpenMP/OMPContext.h b/linux-x64/clang/include/llvm/Frontend/OpenMP/OMPContext.h
new file mode 100644
index 0000000..8a41791
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Frontend/OpenMP/OMPContext.h
@@ -0,0 +1,210 @@
+//===- OpenMP/OMPContext.h ----- OpenMP context helper functions - C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+/// \file
+///
+/// This file provides helper functions and classes to deal with OpenMP
+/// contexts as used by `[begin/end] declare variant` and `metadirective`.
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_OPENMP_CONTEXT_H
+#define LLVM_OPENMP_CONTEXT_H
+
+#include "llvm/ADT/APSInt.h"
+#include "llvm/ADT/BitVector.h"
+#include "llvm/ADT/SetVector.h"
+#include "llvm/ADT/SmallSet.h"
+#include "llvm/ADT/Triple.h"
+#include "llvm/Frontend/OpenMP/OMPConstants.h"
+
+namespace llvm {
+namespace omp {
+
+/// OpenMP Context related IDs and helpers
+///
+///{
+
+/// IDs for all OpenMP context selector trait sets (construct/device/...).
+enum class TraitSet {
+#define OMP_TRAIT_SET(Enum, ...) Enum,
+#include "llvm/Frontend/OpenMP/OMPKinds.def"
+};
+
+/// IDs for all OpenMP context selector trait (device={kind/isa...}/...).
+enum class TraitSelector {
+#define OMP_TRAIT_SELECTOR(Enum, ...) Enum,
+#include "llvm/Frontend/OpenMP/OMPKinds.def"
+};
+
+/// IDs for all OpenMP context trait properties (host/gpu/bsc/llvm/...)
+enum class TraitProperty {
+#define OMP_TRAIT_PROPERTY(Enum, ...) Enum,
+#define OMP_LAST_TRAIT_PROPERTY(Enum) Last = Enum
+#include "llvm/Frontend/OpenMP/OMPKinds.def"
+};
+
+/// Parse \p Str and return the trait set it matches or TraitSet::invalid.
+TraitSet getOpenMPContextTraitSetKind(StringRef Str);
+
+/// Return the trait set for which \p Selector is a selector.
+TraitSet getOpenMPContextTraitSetForSelector(TraitSelector Selector);
+
+/// Return the trait set for which \p Property is a property.
+TraitSet getOpenMPContextTraitSetForProperty(TraitProperty Property);
+
+/// Return a textual representation of the trait set \p Kind.
+StringRef getOpenMPContextTraitSetName(TraitSet Kind);
+
+/// Parse \p Str and return the trait set it matches or
+/// TraitSelector::invalid.
+TraitSelector getOpenMPContextTraitSelectorKind(StringRef Str);
+
+/// Return the trait selector for which \p Property is a property.
+TraitSelector getOpenMPContextTraitSelectorForProperty(TraitProperty Property);
+
+/// Return a textual representation of the trait selector \p Kind.
+StringRef getOpenMPContextTraitSelectorName(TraitSelector Kind);
+
+/// Parse \p Str and return the trait property it matches in the set \p Set and
+/// selector \p Selector or TraitProperty::invalid.
+TraitProperty getOpenMPContextTraitPropertyKind(TraitSet Set,
+ TraitSelector Selector,
+ StringRef Str);
+
+/// Return the trait property for a singleton selector \p Selector.
+TraitProperty getOpenMPContextTraitPropertyForSelector(TraitSelector Selector);
+
+/// Return a textual representation of the trait property \p Kind, which might
+/// be the raw string we parsed (\p RawString) if we do not translate the
+/// property into a (distinct) enum.
+StringRef getOpenMPContextTraitPropertyName(TraitProperty Kind,
+ StringRef RawString);
+
+/// Return a textual representation of the trait property \p Kind with selector
+/// and set name included.
+StringRef getOpenMPContextTraitPropertyFullName(TraitProperty Kind);
+
+/// Return a string listing all trait sets.
+std::string listOpenMPContextTraitSets();
+
+/// Return a string listing all trait selectors for \p Set.
+std::string listOpenMPContextTraitSelectors(TraitSet Set);
+
+/// Return a string listing all trait properties for \p Set and \p Selector.
+std::string listOpenMPContextTraitProperties(TraitSet Set,
+ TraitSelector Selector);
+///}
+
+/// Return true if \p Selector can be nested in \p Set. Also sets
+/// \p AllowsTraitScore and \p RequiresProperty to true/false if the user can
+/// specify a score for properties in \p Selector and if the \p Selector
+/// requires at least one property.
+bool isValidTraitSelectorForTraitSet(TraitSelector Selector, TraitSet Set,
+ bool &AllowsTraitScore,
+ bool &RequiresProperty);
+
+/// Return true if \p Property can be nested in \p Selector and \p Set.
+bool isValidTraitPropertyForTraitSetAndSelector(TraitProperty Property,
+ TraitSelector Selector,
+ TraitSet Set);
+
+/// Variant match information describes the required traits and how they are
+/// scored (via the ScoresMap). In addition, the required consturct nesting is
+/// decribed as well.
+struct VariantMatchInfo {
+ /// Add the trait \p Property to the required trait set. \p RawString is the
+ /// string we parsed and derived \p Property from. If \p Score is not null, it
+ /// recorded as well. If \p Property is in the `construct` set it is recorded
+ /// in-order in the ConstructTraits as well.
+ void addTrait(TraitProperty Property, StringRef RawString,
+ APInt *Score = nullptr) {
+ addTrait(getOpenMPContextTraitSetForProperty(Property), Property, RawString,
+ Score);
+ }
+ /// Add the trait \p Property which is in set \p Set to the required trait
+ /// set. \p RawString is the string we parsed and derived \p Property from. If
+ /// \p Score is not null, it recorded as well. If \p Set is the `construct`
+ /// set it is recorded in-order in the ConstructTraits as well.
+ void addTrait(TraitSet Set, TraitProperty Property, StringRef RawString,
+ APInt *Score = nullptr) {
+ if (Score)
+ ScoreMap[Property] = *Score;
+
+ // Special handling for `device={isa(...)}` as we do not match the enum but
+ // the raw string.
+ if (Property == TraitProperty::device_isa___ANY)
+ ISATraits.push_back(RawString);
+
+ RequiredTraits.set(unsigned(Property));
+ if (Set == TraitSet::construct)
+ ConstructTraits.push_back(Property);
+ }
+
+ BitVector RequiredTraits = BitVector(unsigned(TraitProperty::Last) + 1);
+ SmallVector<StringRef, 8> ISATraits;
+ SmallVector<TraitProperty, 8> ConstructTraits;
+ SmallDenseMap<TraitProperty, APInt> ScoreMap;
+};
+
+/// The context for a source location is made up of active property traits,
+/// e.g., device={kind(host)}, and constructs traits which describe the nesting
+/// in OpenMP constructs at the location.
+struct OMPContext {
+ OMPContext(bool IsDeviceCompilation, Triple TargetTriple);
+ virtual ~OMPContext() = default;
+
+ void addTrait(TraitProperty Property) {
+ addTrait(getOpenMPContextTraitSetForProperty(Property), Property);
+ }
+ void addTrait(TraitSet Set, TraitProperty Property) {
+ ActiveTraits.set(unsigned(Property));
+ if (Set == TraitSet::construct)
+ ConstructTraits.push_back(Property);
+ }
+
+ /// Hook for users to check if an ISA trait matches. The trait is described as
+ /// the string that got parsed and it depends on the target and context if
+ /// this matches or not.
+ virtual bool matchesISATrait(StringRef) const { return false; }
+
+ BitVector ActiveTraits = BitVector(unsigned(TraitProperty::Last) + 1);
+ SmallVector<TraitProperty, 8> ConstructTraits;
+};
+
+/// Return true if \p VMI is applicable in \p Ctx, that is, all traits required
+/// by \p VMI are available in the OpenMP context \p Ctx. If \p DeviceSetOnly is
+/// true, only the device selector set, if present, are checked. Note that we
+/// still honor extension traits provided by the user.
+bool isVariantApplicableInContext(const VariantMatchInfo &VMI,
+ const OMPContext &Ctx,
+ bool DeviceSetOnly = false);
+
+/// Return the index (into \p VMIs) of the variant with the highest score
+/// from the ones applicble in \p Ctx. See llvm::isVariantApplicableInContext.
+int getBestVariantMatchForContext(const SmallVectorImpl<VariantMatchInfo> &VMIs,
+ const OMPContext &Ctx);
+
+} // namespace omp
+
+template <> struct DenseMapInfo<omp::TraitProperty> {
+ static inline omp::TraitProperty getEmptyKey() {
+ return omp::TraitProperty(-1);
+ }
+ static inline omp::TraitProperty getTombstoneKey() {
+ return omp::TraitProperty(-2);
+ }
+ static unsigned getHashValue(omp::TraitProperty val) {
+ return std::hash<unsigned>{}(unsigned(val));
+ }
+ static bool isEqual(omp::TraitProperty LHS, omp::TraitProperty RHS) {
+ return LHS == RHS;
+ }
+};
+
+} // end namespace llvm
+#endif // LLVM_OPENMP_CONTEXT_H
diff --git a/linux-x64/clang/include/llvm/Frontend/OpenMP/OMPGridValues.h b/linux-x64/clang/include/llvm/Frontend/OpenMP/OMPGridValues.h
new file mode 100644
index 0000000..6b48cc4
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Frontend/OpenMP/OMPGridValues.h
@@ -0,0 +1,131 @@
+//====--- OMPGridValues.h - Language-specific address spaces --*- C++ -*-====//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// \brief Provides definitions for Target specific Grid Values
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_OPENMP_GRIDVALUES_H
+#define LLVM_OPENMP_GRIDVALUES_H
+
+namespace llvm {
+
+namespace omp {
+
+/// \brief Defines various target-specific GPU grid values that must be
+/// consistent between host RTL (plugin), device RTL, and clang.
+/// We can change grid values for a "fat" binary so that different
+/// passes get the correct values when generating code for a
+/// multi-target binary. Both amdgcn and nvptx values are stored in
+/// this file. In the future, should there be differences between GPUs
+/// of the same architecture, then simply make a different array and
+/// use the new array name.
+///
+/// Example usage in clang:
+/// const unsigned slot_size =
+/// ctx.GetTargetInfo().getGridValue(llvm::omp::GVIDX::GV_Warp_Size);
+///
+/// Example usage in libomptarget/deviceRTLs:
+/// #include "llvm/Frontend/OpenMP/OMPGridValues.h"
+/// #ifdef __AMDGPU__
+/// #define GRIDVAL AMDGPUGpuGridValues
+/// #else
+/// #define GRIDVAL NVPTXGpuGridValues
+/// #endif
+/// ... Then use this reference for GV_Warp_Size in the deviceRTL source.
+/// llvm::omp::GRIDVAL[llvm::omp::GVIDX::GV_Warp_Size]
+///
+/// Example usage in libomptarget hsa plugin:
+/// #include "llvm/Frontend/OpenMP/OMPGridValues.h"
+/// #define GRIDVAL AMDGPUGpuGridValues
+/// ... Then use this reference to access GV_Warp_Size in the hsa plugin.
+/// llvm::omp::GRIDVAL[llvm::omp::GVIDX::GV_Warp_Size]
+///
+/// Example usage in libomptarget cuda plugin:
+/// #include "llvm/Frontend/OpenMP/OMPGridValues.h"
+/// #define GRIDVAL NVPTXGpuGridValues
+/// ... Then use this reference to access GV_Warp_Size in the cuda plugin.
+/// llvm::omp::GRIDVAL[llvm::omp::GVIDX::GV_Warp_Size]
+///
+enum GVIDX {
+ /// The maximum number of workers in a kernel.
+ /// (THREAD_ABSOLUTE_LIMIT) - (GV_Warp_Size), might be issue for blockDim.z
+ GV_Threads,
+ /// The size reserved for data in a shared memory slot.
+ GV_Slot_Size,
+ /// The default value of maximum number of threads in a worker warp.
+ GV_Warp_Size,
+ /// Alternate warp size for some AMDGCN architectures. Same as GV_Warp_Size
+ /// for NVPTX.
+ GV_Warp_Size_32,
+ /// The number of bits required to represent the max number of threads in warp
+ GV_Warp_Size_Log2,
+ /// GV_Warp_Size * GV_Slot_Size,
+ GV_Warp_Slot_Size,
+ /// the maximum number of teams.
+ GV_Max_Teams,
+ /// Global Memory Alignment
+ GV_Mem_Align,
+ /// (~0u >> (GV_Warp_Size - GV_Warp_Size_Log2))
+ GV_Warp_Size_Log2_Mask,
+ // An alternative to the heavy data sharing infrastructure that uses global
+ // memory is one that uses device __shared__ memory. The amount of such space
+ // (in bytes) reserved by the OpenMP runtime is noted here.
+ GV_SimpleBufferSize,
+ // The absolute maximum team size for a working group
+ GV_Max_WG_Size,
+ // The default maximum team size for a working group
+ GV_Default_WG_Size,
+ // This is GV_Max_WG_Size / GV_WarpSize. 32 for NVPTX and 16 for AMDGCN.
+ GV_Max_Warp_Number,
+ /// The slot size that should be reserved for a working warp.
+ /// (~0u >> (GV_Warp_Size - GV_Warp_Size_Log2))
+ GV_Warp_Size_Log2_MaskL
+};
+
+/// For AMDGPU GPUs
+static constexpr unsigned AMDGPUGpuGridValues[] = {
+ 448, // GV_Threads
+ 256, // GV_Slot_Size
+ 64, // GV_Warp_Size
+ 32, // GV_Warp_Size_32
+ 6, // GV_Warp_Size_Log2
+ 64 * 256, // GV_Warp_Slot_Size
+ 128, // GV_Max_Teams
+ 256, // GV_Mem_Align
+ 63, // GV_Warp_Size_Log2_Mask
+ 896, // GV_SimpleBufferSize
+ 1024, // GV_Max_WG_Size,
+ 256, // GV_Defaut_WG_Size
+ 1024 / 64, // GV_Max_WG_Size / GV_WarpSize
+ 63 // GV_Warp_Size_Log2_MaskL
+};
+
+/// For Nvidia GPUs
+static constexpr unsigned NVPTXGpuGridValues[] = {
+ 992, // GV_Threads
+ 256, // GV_Slot_Size
+ 32, // GV_Warp_Size
+ 32, // GV_Warp_Size_32
+ 5, // GV_Warp_Size_Log2
+ 32 * 256, // GV_Warp_Slot_Size
+ 1024, // GV_Max_Teams
+ 256, // GV_Mem_Align
+ (~0u >> (32 - 5)), // GV_Warp_Size_Log2_Mask
+ 896, // GV_SimpleBufferSize
+ 1024, // GV_Max_WG_Size
+ 128, // GV_Defaut_WG_Size
+ 1024 / 32, // GV_Max_WG_Size / GV_WarpSize
+ 31 // GV_Warp_Size_Log2_MaskL
+};
+
+} // namespace omp
+} // namespace llvm
+
+#endif // LLVM_OPENMP_GRIDVALUES_H
diff --git a/linux-x64/clang/include/llvm/Frontend/OpenMP/OMPIRBuilder.h b/linux-x64/clang/include/llvm/Frontend/OpenMP/OMPIRBuilder.h
new file mode 100644
index 0000000..8e95226
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Frontend/OpenMP/OMPIRBuilder.h
@@ -0,0 +1,800 @@
+//===- IR/OpenMPIRBuilder.h - OpenMP encoding builder for LLVM IR - C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines the OpenMPIRBuilder class and helpers used as a convenient
+// way to create LLVM instructions for OpenMP directives.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_OPENMP_IR_IRBUILDER_H
+#define LLVM_OPENMP_IR_IRBUILDER_H
+
+#include "llvm/Frontend/OpenMP/OMPConstants.h"
+#include "llvm/IR/DebugLoc.h"
+#include "llvm/IR/IRBuilder.h"
+#include "llvm/Support/Allocator.h"
+#include <forward_list>
+
+namespace llvm {
+class CanonicalLoopInfo;
+
+/// An interface to create LLVM-IR for OpenMP directives.
+///
+/// Each OpenMP directive has a corresponding public generator method.
+class OpenMPIRBuilder {
+public:
+ /// Create a new OpenMPIRBuilder operating on the given module \p M. This will
+ /// not have an effect on \p M (see initialize).
+ OpenMPIRBuilder(Module &M) : M(M), Builder(M.getContext()) {}
+
+ /// Initialize the internal state, this will put structures types and
+ /// potentially other helpers into the underlying module. Must be called
+ /// before any other method and only once!
+ void initialize();
+
+ /// Finalize the underlying module, e.g., by outlining regions.
+ /// \param AllowExtractorSinking Flag to include sinking instructions,
+ /// emitted by CodeExtractor, in the
+ /// outlined region. Default is false.
+ void finalize(bool AllowExtractorSinking = false);
+
+ /// Add attributes known for \p FnID to \p Fn.
+ void addAttributes(omp::RuntimeFunction FnID, Function &Fn);
+
+ /// Type used throughout for insertion points.
+ using InsertPointTy = IRBuilder<>::InsertPoint;
+
+ /// Callback type for variable finalization (think destructors).
+ ///
+ /// \param CodeGenIP is the insertion point at which the finalization code
+ /// should be placed.
+ ///
+ /// A finalize callback knows about all objects that need finalization, e.g.
+ /// destruction, when the scope of the currently generated construct is left
+ /// at the time, and location, the callback is invoked.
+ using FinalizeCallbackTy = std::function<void(InsertPointTy CodeGenIP)>;
+
+ struct FinalizationInfo {
+ /// The finalization callback provided by the last in-flight invocation of
+ /// createXXXX for the directive of kind DK.
+ FinalizeCallbackTy FiniCB;
+
+ /// The directive kind of the innermost directive that has an associated
+ /// region which might require finalization when it is left.
+ omp::Directive DK;
+
+ /// Flag to indicate if the directive is cancellable.
+ bool IsCancellable;
+ };
+
+ /// Push a finalization callback on the finalization stack.
+ ///
+ /// NOTE: Temporary solution until Clang CG is gone.
+ void pushFinalizationCB(const FinalizationInfo &FI) {
+ FinalizationStack.push_back(FI);
+ }
+
+ /// Pop the last finalization callback from the finalization stack.
+ ///
+ /// NOTE: Temporary solution until Clang CG is gone.
+ void popFinalizationCB() { FinalizationStack.pop_back(); }
+
+ /// Callback type for body (=inner region) code generation
+ ///
+ /// The callback takes code locations as arguments, each describing a
+ /// location at which code might need to be generated or a location that is
+ /// the target of control transfer.
+ ///
+ /// \param AllocaIP is the insertion point at which new alloca instructions
+ /// should be placed.
+ /// \param CodeGenIP is the insertion point at which the body code should be
+ /// placed.
+ /// \param ContinuationBB is the basic block target to leave the body.
+ ///
+ /// Note that all blocks pointed to by the arguments have terminators.
+ using BodyGenCallbackTy =
+ function_ref<void(InsertPointTy AllocaIP, InsertPointTy CodeGenIP,
+ BasicBlock &ContinuationBB)>;
+
+ /// Callback type for loop body code generation.
+ ///
+ /// \param CodeGenIP is the insertion point where the loop's body code must be
+ /// placed. This will be a dedicated BasicBlock with a
+ /// conditional branch from the loop condition check and
+ /// terminated with an unconditional branch to the loop
+ /// latch.
+ /// \param IndVar is the induction variable usable at the insertion point.
+ using LoopBodyGenCallbackTy =
+ function_ref<void(InsertPointTy CodeGenIP, Value *IndVar)>;
+
+ /// Callback type for variable privatization (think copy & default
+ /// constructor).
+ ///
+ /// \param AllocaIP is the insertion point at which new alloca instructions
+ /// should be placed.
+ /// \param CodeGenIP is the insertion point at which the privatization code
+ /// should be placed.
+ /// \param Original The value being copied/created, should not be used in the
+ /// generated IR.
+ /// \param Inner The equivalent of \p Original that should be used in the
+ /// generated IR; this is equal to \p Original if the value is
+ /// a pointer and can thus be passed directly, otherwise it is
+ /// an equivalent but different value.
+ /// \param ReplVal The replacement value, thus a copy or new created version
+ /// of \p Inner.
+ ///
+ /// \returns The new insertion point where code generation continues and
+ /// \p ReplVal the replacement value.
+ using PrivatizeCallbackTy = function_ref<InsertPointTy(
+ InsertPointTy AllocaIP, InsertPointTy CodeGenIP, Value &Original,
+ Value &Inner, Value *&ReplVal)>;
+
+ /// Description of a LLVM-IR insertion point (IP) and a debug/source location
+ /// (filename, line, column, ...).
+ struct LocationDescription {
+ template <typename T, typename U>
+ LocationDescription(const IRBuilder<T, U> &IRB)
+ : IP(IRB.saveIP()), DL(IRB.getCurrentDebugLocation()) {}
+ LocationDescription(const InsertPointTy &IP) : IP(IP) {}
+ LocationDescription(const InsertPointTy &IP, const DebugLoc &DL)
+ : IP(IP), DL(DL) {}
+ InsertPointTy IP;
+ DebugLoc DL;
+ };
+
+ /// Emitter methods for OpenMP directives.
+ ///
+ ///{
+
+ /// Generator for '#omp barrier'
+ ///
+ /// \param Loc The location where the barrier directive was encountered.
+ /// \param DK The kind of directive that caused the barrier.
+ /// \param ForceSimpleCall Flag to force a simple (=non-cancellation) barrier.
+ /// \param CheckCancelFlag Flag to indicate a cancel barrier return value
+ /// should be checked and acted upon.
+ ///
+ /// \returns The insertion point after the barrier.
+ InsertPointTy createBarrier(const LocationDescription &Loc, omp::Directive DK,
+ bool ForceSimpleCall = false,
+ bool CheckCancelFlag = true);
+
+ /// Generator for '#omp cancel'
+ ///
+ /// \param Loc The location where the directive was encountered.
+ /// \param IfCondition The evaluated 'if' clause expression, if any.
+ /// \param CanceledDirective The kind of directive that is cancled.
+ ///
+ /// \returns The insertion point after the barrier.
+ InsertPointTy createCancel(const LocationDescription &Loc, Value *IfCondition,
+ omp::Directive CanceledDirective);
+
+ /// Generator for '#omp parallel'
+ ///
+ /// \param Loc The insert and source location description.
+ /// \param AllocaIP The insertion points to be used for alloca instructions.
+ /// \param BodyGenCB Callback that will generate the region code.
+ /// \param PrivCB Callback to copy a given variable (think copy constructor).
+ /// \param FiniCB Callback to finalize variable copies.
+ /// \param IfCondition The evaluated 'if' clause expression, if any.
+ /// \param NumThreads The evaluated 'num_threads' clause expression, if any.
+ /// \param ProcBind The value of the 'proc_bind' clause (see ProcBindKind).
+ /// \param IsCancellable Flag to indicate a cancellable parallel region.
+ ///
+ /// \returns The insertion position *after* the parallel.
+ IRBuilder<>::InsertPoint
+ createParallel(const LocationDescription &Loc, InsertPointTy AllocaIP,
+ BodyGenCallbackTy BodyGenCB, PrivatizeCallbackTy PrivCB,
+ FinalizeCallbackTy FiniCB, Value *IfCondition,
+ Value *NumThreads, omp::ProcBindKind ProcBind,
+ bool IsCancellable);
+
+ /// Generator for the control flow structure of an OpenMP canonical loop.
+ ///
+ /// This generator operates on the logical iteration space of the loop, i.e.
+ /// the caller only has to provide a loop trip count of the loop as defined by
+ /// base language semantics. The trip count is interpreted as an unsigned
+ /// integer. The induction variable passed to \p BodyGenCB will be of the same
+ /// type and run from 0 to \p TripCount - 1. It is up to the callback to
+ /// convert the logical iteration variable to the loop counter variable in the
+ /// loop body.
+ ///
+ /// \param Loc The insert and source location description. The insert
+ /// location can be between two instructions or the end of a
+ /// degenerate block (e.g. a BB under construction).
+ /// \param BodyGenCB Callback that will generate the loop body code.
+ /// \param TripCount Number of iterations the loop body is executed.
+ /// \param Name Base name used to derive BB and instruction names.
+ ///
+ /// \returns An object representing the created control flow structure which
+ /// can be used for loop-associated directives.
+ CanonicalLoopInfo *createCanonicalLoop(const LocationDescription &Loc,
+ LoopBodyGenCallbackTy BodyGenCB,
+ Value *TripCount,
+ const Twine &Name = "loop");
+
+ /// Generator for the control flow structure of an OpenMP canonical loop.
+ ///
+ /// Instead of a logical iteration space, this allows specifying user-defined
+ /// loop counter values using increment, upper- and lower bounds. To
+ /// disambiguate the terminology when counting downwards, instead of lower
+ /// bounds we use \p Start for the loop counter value in the first body
+ /// iteration.
+ ///
+ /// Consider the following limitations:
+ ///
+ /// * A loop counter space over all integer values of its bit-width cannot be
+ /// represented. E.g using uint8_t, its loop trip count of 256 cannot be
+ /// stored into an 8 bit integer):
+ ///
+ /// DO I = 0, 255, 1
+ ///
+ /// * Unsigned wrapping is only supported when wrapping only "once"; E.g.
+ /// effectively counting downwards:
+ ///
+ /// for (uint8_t i = 100u; i > 0; i += 127u)
+ ///
+ ///
+ /// TODO: May need to add additional parameters to represent:
+ ///
+ /// * Allow representing downcounting with unsigned integers.
+ ///
+ /// * Sign of the step and the comparison operator might disagree:
+ ///
+ /// for (int i = 0; i < 42; --i)
+ ///
+ //
+ /// \param Loc The insert and source location description.
+ /// \param BodyGenCB Callback that will generate the loop body code.
+ /// \param Start Value of the loop counter for the first iterations.
+ /// \param Stop Loop counter values past this will stop the the
+ /// iterations.
+ /// \param Step Loop counter increment after each iteration; negative
+ /// means counting down. \param IsSigned Whether Start, Stop
+ /// and Stop are signed integers.
+ /// \param InclusiveStop Whether \p Stop itself is a valid value for the loop
+ /// counter.
+ /// \param ComputeIP Insertion point for instructions computing the trip
+ /// count. Can be used to ensure the trip count is available
+ /// at the outermost loop of a loop nest. If not set,
+ /// defaults to the preheader of the generated loop.
+ /// \param Name Base name used to derive BB and instruction names.
+ ///
+ /// \returns An object representing the created control flow structure which
+ /// can be used for loop-associated directives.
+ CanonicalLoopInfo *createCanonicalLoop(const LocationDescription &Loc,
+ LoopBodyGenCallbackTy BodyGenCB,
+ Value *Start, Value *Stop, Value *Step,
+ bool IsSigned, bool InclusiveStop,
+ InsertPointTy ComputeIP = {},
+ const Twine &Name = "loop");
+
+ /// Modifies the canonical loop to be a statically-scheduled workshare loop.
+ ///
+ /// This takes a \p LoopInfo representing a canonical loop, such as the one
+ /// created by \p createCanonicalLoop and emits additional instructions to
+ /// turn it into a workshare loop. In particular, it calls to an OpenMP
+ /// runtime function in the preheader to obtain the loop bounds to be used in
+ /// the current thread, updates the relevant instructions in the canonical
+ /// loop and calls to an OpenMP runtime finalization function after the loop.
+ ///
+ /// \param Loc The source location description, the insertion location
+ /// is not used.
+ /// \param CLI A descriptor of the canonical loop to workshare.
+ /// \param AllocaIP An insertion point for Alloca instructions usable in the
+ /// preheader of the loop.
+ /// \param NeedsBarrier Indicates whether a barrier must be insterted after
+ /// the loop.
+ /// \param Chunk The size of loop chunk considered as a unit when
+ /// scheduling. If \p nullptr, defaults to 1.
+ ///
+ /// \returns Updated CanonicalLoopInfo.
+ CanonicalLoopInfo *createStaticWorkshareLoop(const LocationDescription &Loc,
+ CanonicalLoopInfo *CLI,
+ InsertPointTy AllocaIP,
+ bool NeedsBarrier,
+ Value *Chunk = nullptr);
+
+ /// Generator for '#omp flush'
+ ///
+ /// \param Loc The location where the flush directive was encountered
+ void createFlush(const LocationDescription &Loc);
+
+ /// Generator for '#omp taskwait'
+ ///
+ /// \param Loc The location where the taskwait directive was encountered.
+ void createTaskwait(const LocationDescription &Loc);
+
+ /// Generator for '#omp taskyield'
+ ///
+ /// \param Loc The location where the taskyield directive was encountered.
+ void createTaskyield(const LocationDescription &Loc);
+
+ ///}
+
+ /// Return the insertion point used by the underlying IRBuilder.
+ InsertPointTy getInsertionPoint() { return Builder.saveIP(); }
+
+ /// Update the internal location to \p Loc.
+ bool updateToLocation(const LocationDescription &Loc) {
+ Builder.restoreIP(Loc.IP);
+ Builder.SetCurrentDebugLocation(Loc.DL);
+ return Loc.IP.getBlock() != nullptr;
+ }
+
+ /// Return the function declaration for the runtime function with \p FnID.
+ FunctionCallee getOrCreateRuntimeFunction(Module &M,
+ omp::RuntimeFunction FnID);
+
+ Function *getOrCreateRuntimeFunctionPtr(omp::RuntimeFunction FnID);
+
+ /// Return the (LLVM-IR) string describing the source location \p LocStr.
+ Constant *getOrCreateSrcLocStr(StringRef LocStr);
+
+ /// Return the (LLVM-IR) string describing the default source location.
+ Constant *getOrCreateDefaultSrcLocStr();
+
+ /// Return the (LLVM-IR) string describing the source location identified by
+ /// the arguments.
+ Constant *getOrCreateSrcLocStr(StringRef FunctionName, StringRef FileName,
+ unsigned Line, unsigned Column);
+
+ /// Return the (LLVM-IR) string describing the source location \p Loc.
+ Constant *getOrCreateSrcLocStr(const LocationDescription &Loc);
+
+ /// Return an ident_t* encoding the source location \p SrcLocStr and \p Flags.
+ /// TODO: Create a enum class for the Reserve2Flags
+ Value *getOrCreateIdent(Constant *SrcLocStr,
+ omp::IdentFlag Flags = omp::IdentFlag(0),
+ unsigned Reserve2Flags = 0);
+
+ // Get the type corresponding to __kmpc_impl_lanemask_t from the deviceRTL
+ Type *getLanemaskType();
+
+ /// Generate control flow and cleanup for cancellation.
+ ///
+ /// \param CancelFlag Flag indicating if the cancellation is performed.
+ /// \param CanceledDirective The kind of directive that is cancled.
+ void emitCancelationCheckImpl(Value *CancelFlag,
+ omp::Directive CanceledDirective);
+
+ /// Generate a barrier runtime call.
+ ///
+ /// \param Loc The location at which the request originated and is fulfilled.
+ /// \param DK The directive which caused the barrier
+ /// \param ForceSimpleCall Flag to force a simple (=non-cancellation) barrier.
+ /// \param CheckCancelFlag Flag to indicate a cancel barrier return value
+ /// should be checked and acted upon.
+ ///
+ /// \returns The insertion point after the barrier.
+ InsertPointTy emitBarrierImpl(const LocationDescription &Loc,
+ omp::Directive DK, bool ForceSimpleCall,
+ bool CheckCancelFlag);
+
+ /// Generate a flush runtime call.
+ ///
+ /// \param Loc The location at which the request originated and is fulfilled.
+ void emitFlush(const LocationDescription &Loc);
+
+ /// The finalization stack made up of finalize callbacks currently in-flight,
+ /// wrapped into FinalizationInfo objects that reference also the finalization
+ /// target block and the kind of cancellable directive.
+ SmallVector<FinalizationInfo, 8> FinalizationStack;
+
+ /// Return true if the last entry in the finalization stack is of kind \p DK
+ /// and cancellable.
+ bool isLastFinalizationInfoCancellable(omp::Directive DK) {
+ return !FinalizationStack.empty() &&
+ FinalizationStack.back().IsCancellable &&
+ FinalizationStack.back().DK == DK;
+ }
+
+ /// Generate a taskwait runtime call.
+ ///
+ /// \param Loc The location at which the request originated and is fulfilled.
+ void emitTaskwaitImpl(const LocationDescription &Loc);
+
+ /// Generate a taskyield runtime call.
+ ///
+ /// \param Loc The location at which the request originated and is fulfilled.
+ void emitTaskyieldImpl(const LocationDescription &Loc);
+
+ /// Return the current thread ID.
+ ///
+ /// \param Ident The ident (ident_t*) describing the query origin.
+ Value *getOrCreateThreadID(Value *Ident);
+
+ /// The underlying LLVM-IR module
+ Module &M;
+
+ /// The LLVM-IR Builder used to create IR.
+ IRBuilder<> Builder;
+
+ /// Map to remember source location strings
+ StringMap<Constant *> SrcLocStrMap;
+
+ /// Map to remember existing ident_t*.
+ DenseMap<std::pair<Constant *, uint64_t>, Value *> IdentMap;
+
+ /// Helper that contains information about regions we need to outline
+ /// during finalization.
+ struct OutlineInfo {
+ using PostOutlineCBTy = std::function<void(Function &)>;
+ PostOutlineCBTy PostOutlineCB;
+ BasicBlock *EntryBB, *ExitBB;
+
+ /// Collect all blocks in between EntryBB and ExitBB in both the given
+ /// vector and set.
+ void collectBlocks(SmallPtrSetImpl<BasicBlock *> &BlockSet,
+ SmallVectorImpl<BasicBlock *> &BlockVector);
+ };
+
+ /// Collection of regions that need to be outlined during finalization.
+ SmallVector<OutlineInfo, 16> OutlineInfos;
+
+ /// Collection of owned canonical loop objects that eventually need to be
+ /// free'd.
+ std::forward_list<CanonicalLoopInfo> LoopInfos;
+
+ /// Add a new region that will be outlined later.
+ void addOutlineInfo(OutlineInfo &&OI) { OutlineInfos.emplace_back(OI); }
+
+ /// An ordered map of auto-generated variables to their unique names.
+ /// It stores variables with the following names: 1) ".gomp_critical_user_" +
+ /// <critical_section_name> + ".var" for "omp critical" directives; 2)
+ /// <mangled_name_for_global_var> + ".cache." for cache for threadprivate
+ /// variables.
+ StringMap<AssertingVH<Constant>, BumpPtrAllocator> InternalVars;
+
+public:
+ /// Generator for __kmpc_copyprivate
+ ///
+ /// \param Loc The source location description.
+ /// \param BufSize Number of elements in the buffer.
+ /// \param CpyBuf List of pointers to data to be copied.
+ /// \param CpyFn function to call for copying data.
+ /// \param DidIt flag variable; 1 for 'single' thread, 0 otherwise.
+ ///
+ /// \return The insertion position *after* the CopyPrivate call.
+
+ InsertPointTy createCopyPrivate(const LocationDescription &Loc,
+ llvm::Value *BufSize, llvm::Value *CpyBuf,
+ llvm::Value *CpyFn, llvm::Value *DidIt);
+
+ /// Generator for '#omp single'
+ ///
+ /// \param Loc The source location description.
+ /// \param BodyGenCB Callback that will generate the region code.
+ /// \param FiniCB Callback to finalize variable copies.
+ /// \param DidIt Local variable used as a flag to indicate 'single' thread
+ ///
+ /// \returns The insertion position *after* the single call.
+ InsertPointTy createSingle(const LocationDescription &Loc,
+ BodyGenCallbackTy BodyGenCB,
+ FinalizeCallbackTy FiniCB, llvm::Value *DidIt);
+
+ /// Generator for '#omp master'
+ ///
+ /// \param Loc The insert and source location description.
+ /// \param BodyGenCB Callback that will generate the region code.
+ /// \param FiniCB Callback to finalize variable copies.
+ ///
+ /// \returns The insertion position *after* the master.
+ InsertPointTy createMaster(const LocationDescription &Loc,
+ BodyGenCallbackTy BodyGenCB,
+ FinalizeCallbackTy FiniCB);
+
+ /// Generator for '#omp critical'
+ ///
+ /// \param Loc The insert and source location description.
+ /// \param BodyGenCB Callback that will generate the region body code.
+ /// \param FiniCB Callback to finalize variable copies.
+ /// \param CriticalName name of the lock used by the critical directive
+ /// \param HintInst Hint Instruction for hint clause associated with critical
+ ///
+ /// \returns The insertion position *after* the master.
+ InsertPointTy createCritical(const LocationDescription &Loc,
+ BodyGenCallbackTy BodyGenCB,
+ FinalizeCallbackTy FiniCB,
+ StringRef CriticalName, Value *HintInst);
+
+ /// Generate conditional branch and relevant BasicBlocks through which private
+ /// threads copy the 'copyin' variables from Master copy to threadprivate
+ /// copies.
+ ///
+ /// \param IP insertion block for copyin conditional
+ /// \param MasterVarPtr a pointer to the master variable
+ /// \param PrivateVarPtr a pointer to the threadprivate variable
+ /// \param IntPtrTy Pointer size type
+ /// \param BranchtoEnd Create a branch between the copyin.not.master blocks
+ // and copy.in.end block
+ ///
+ /// \returns The insertion point where copying operation to be emitted.
+ InsertPointTy createCopyinClauseBlocks(InsertPointTy IP, Value *MasterAddr,
+ Value *PrivateAddr,
+ llvm::IntegerType *IntPtrTy,
+ bool BranchtoEnd = true);
+
+ /// Create a runtime call for kmpc_Alloc
+ ///
+ /// \param Loc The insert and source location description.
+ /// \param Size Size of allocated memory space
+ /// \param Allocator Allocator information instruction
+ /// \param Name Name of call Instruction for OMP_alloc
+ ///
+ /// \returns CallInst to the OMP_Alloc call
+ CallInst *createOMPAlloc(const LocationDescription &Loc, Value *Size,
+ Value *Allocator, std::string Name = "");
+
+ /// Create a runtime call for kmpc_free
+ ///
+ /// \param Loc The insert and source location description.
+ /// \param Addr Address of memory space to be freed
+ /// \param Allocator Allocator information instruction
+ /// \param Name Name of call Instruction for OMP_Free
+ ///
+ /// \returns CallInst to the OMP_Free call
+ CallInst *createOMPFree(const LocationDescription &Loc, Value *Addr,
+ Value *Allocator, std::string Name = "");
+
+ /// Create a runtime call for kmpc_threadprivate_cached
+ ///
+ /// \param Loc The insert and source location description.
+ /// \param Pointer pointer to data to be cached
+ /// \param Size size of data to be cached
+ /// \param Name Name of call Instruction for callinst
+ ///
+ /// \returns CallInst to the thread private cache call.
+ CallInst *createCachedThreadPrivate(const LocationDescription &Loc,
+ llvm::Value *Pointer,
+ llvm::ConstantInt *Size,
+ const llvm::Twine &Name = Twine(""));
+
+ /// 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
+ /// values.
+ ///
+ ///{
+#define OMP_TYPE(VarName, InitValue) Type *VarName = nullptr;
+#define OMP_ARRAY_TYPE(VarName, ElemTy, ArraySize) \
+ ArrayType *VarName##Ty = nullptr; \
+ PointerType *VarName##PtrTy = nullptr;
+#define OMP_FUNCTION_TYPE(VarName, IsVarArg, ReturnType, ...) \
+ FunctionType *VarName = nullptr; \
+ PointerType *VarName##Ptr = nullptr;
+#define OMP_STRUCT_TYPE(VarName, StrName, ...) \
+ StructType *VarName = nullptr; \
+ PointerType *VarName##Ptr = nullptr;
+#include "llvm/Frontend/OpenMP/OMPKinds.def"
+
+ ///}
+
+private:
+ /// Create all simple and struct types exposed by the runtime and remember
+ /// the llvm::PointerTypes of them for easy access later.
+ void initializeTypes(Module &M);
+
+ /// Common interface for generating entry calls for OMP Directives.
+ /// if the directive has a region/body, It will set the insertion
+ /// point to the body
+ ///
+ /// \param OMPD Directive to generate entry blocks for
+ /// \param EntryCall Call to the entry OMP Runtime Function
+ /// \param ExitBB block where the region ends.
+ /// \param Conditional indicate if the entry call result will be used
+ /// to evaluate a conditional of whether a thread will execute
+ /// body code or not.
+ ///
+ /// \return The insertion position in exit block
+ InsertPointTy emitCommonDirectiveEntry(omp::Directive OMPD, Value *EntryCall,
+ BasicBlock *ExitBB,
+ bool Conditional = false);
+
+ /// Common interface to finalize the region
+ ///
+ /// \param OMPD Directive to generate exiting code for
+ /// \param FinIP Insertion point for emitting Finalization code and exit call
+ /// \param ExitCall Call to the ending OMP Runtime Function
+ /// \param HasFinalize indicate if the directive will require finalization
+ /// and has a finalization callback in the stack that
+ /// should be called.
+ ///
+ /// \return The insertion position in exit block
+ InsertPointTy emitCommonDirectiveExit(omp::Directive OMPD,
+ InsertPointTy FinIP,
+ Instruction *ExitCall,
+ bool HasFinalize = true);
+
+ /// Common Interface to generate OMP inlined regions
+ ///
+ /// \param OMPD Directive to generate inlined region for
+ /// \param EntryCall Call to the entry OMP Runtime Function
+ /// \param ExitCall Call to the ending OMP Runtime Function
+ /// \param BodyGenCB Body code generation callback.
+ /// \param FiniCB Finalization Callback. Will be called when finalizing region
+ /// \param Conditional indicate if the entry call result will be used
+ /// to evaluate a conditional of whether a thread will execute
+ /// body code or not.
+ /// \param HasFinalize indicate if the directive will require finalization
+ /// and has a finalization callback in the stack that
+ /// should be called.
+ ///
+ /// \return The insertion point after the region
+
+ InsertPointTy
+ EmitOMPInlinedRegion(omp::Directive OMPD, Instruction *EntryCall,
+ Instruction *ExitCall, BodyGenCallbackTy BodyGenCB,
+ FinalizeCallbackTy FiniCB, bool Conditional = false,
+ bool HasFinalize = true);
+
+ /// Get the platform-specific name separator.
+ /// \param Parts different parts of the final name that needs separation
+ /// \param FirstSeparator First separator used between the initial two
+ /// parts of the name.
+ /// \param Separator separator used between all of the rest consecutive
+ /// parts of the name
+ static std::string getNameWithSeparators(ArrayRef<StringRef> Parts,
+ StringRef FirstSeparator,
+ StringRef Separator);
+
+ /// Gets (if variable with the given name already exist) or creates
+ /// internal global variable with the specified Name. The created variable has
+ /// linkage CommonLinkage by default and is initialized by null value.
+ /// \param Ty Type of the global variable. If it is exist already the type
+ /// must be the same.
+ /// \param Name Name of the variable.
+ Constant *getOrCreateOMPInternalVariable(Type *Ty, const Twine &Name,
+ unsigned AddressSpace = 0);
+
+ /// Returns corresponding lock object for the specified critical region
+ /// name. If the lock object does not exist it is created, otherwise the
+ /// reference to the existing copy is returned.
+ /// \param CriticalName Name of the critical region.
+ ///
+ Value *getOMPCriticalRegionLock(StringRef CriticalName);
+
+ /// Create the control flow structure of a canonical OpenMP loop.
+ ///
+ /// The emitted loop will be disconnected, i.e. no edge to the loop's
+ /// preheader and no terminator in the AfterBB. The OpenMPIRBuilder's
+ /// IRBuilder location is not preserved.
+ ///
+ /// \param DL DebugLoc used for the instructions in the skeleton.
+ /// \param TripCount Value to be used for the trip count.
+ /// \param F Function in which to insert the BasicBlocks.
+ /// \param PreInsertBefore Where to insert BBs that execute before the body,
+ /// typically the body itself.
+ /// \param PostInsertBefore Where to insert BBs that execute after the body.
+ /// \param Name Base name used to derive BB
+ /// and instruction names.
+ ///
+ /// \returns The CanonicalLoopInfo that represents the emitted loop.
+ CanonicalLoopInfo *createLoopSkeleton(DebugLoc DL, Value *TripCount,
+ Function *F,
+ BasicBlock *PreInsertBefore,
+ BasicBlock *PostInsertBefore,
+ const Twine &Name = {});
+};
+
+/// Class to represented the control flow structure of an OpenMP canonical loop.
+///
+/// The control-flow structure is standardized for easy consumption by
+/// directives associated with loops. For instance, the worksharing-loop
+/// construct may change this control flow such that each loop iteration is
+/// executed on only one thread.
+///
+/// The control flow can be described as follows:
+///
+/// Preheader
+/// |
+/// /-> Header
+/// | |
+/// | Cond---\
+/// | | |
+/// | Body |
+/// | | | |
+/// | <...> |
+/// | | | |
+/// \--Latch |
+/// |
+/// Exit
+/// |
+/// After
+///
+/// Code in the header, condition block, latch and exit block must not have any
+/// side-effect. The body block is the single entry point into the loop body,
+/// which may contain arbitrary control flow as long as all control paths
+/// eventually branch to the latch block.
+///
+/// Defined outside OpenMPIRBuilder because one cannot forward-declare nested
+/// classes.
+class CanonicalLoopInfo {
+ friend class OpenMPIRBuilder;
+
+private:
+ /// Whether this object currently represents a loop.
+ bool IsValid = false;
+
+ BasicBlock *Preheader;
+ BasicBlock *Header;
+ BasicBlock *Cond;
+ BasicBlock *Body;
+ BasicBlock *Latch;
+ BasicBlock *Exit;
+ BasicBlock *After;
+
+public:
+ /// The preheader ensures that there is only a single edge entering the loop.
+ /// Code that must be execute before any loop iteration can be emitted here,
+ /// such as computing the loop trip count and begin lifetime markers. Code in
+ /// the preheader is not considered part of the canonical loop.
+ BasicBlock *getPreheader() const { return Preheader; }
+
+ /// The header is the entry for each iteration. In the canonical control flow,
+ /// it only contains the PHINode for the induction variable.
+ BasicBlock *getHeader() const { return Header; }
+
+ /// The condition block computes whether there is another loop iteration. If
+ /// yes, branches to the body; otherwise to the exit block.
+ BasicBlock *getCond() const { return Cond; }
+
+ /// The body block is the single entry for a loop iteration and not controlled
+ /// by CanonicalLoopInfo. It can contain arbitrary control flow but must
+ /// eventually branch to the \p Latch block.
+ BasicBlock *getBody() const { return Body; }
+
+ /// Reaching the latch indicates the end of the loop body code. In the
+ /// canonical control flow, it only contains the increment of the induction
+ /// variable.
+ BasicBlock *getLatch() const { return Latch; }
+
+ /// Reaching the exit indicates no more iterations are being executed.
+ BasicBlock *getExit() const { return Exit; }
+
+ /// The after block is intended for clean-up code such as lifetime end
+ /// markers. It is separate from the exit block to ensure, analogous to the
+ /// preheader, it having just a single entry edge and being free from PHI
+ /// nodes should there be multiple loop exits (such as from break
+ /// statements/cancellations).
+ BasicBlock *getAfter() const { return After; }
+
+ /// Returns the llvm::Value containing the number of loop iterations. It must
+ /// be valid in the preheader and always interpreted as an unsigned integer of
+ /// any bit-width.
+ Value *getTripCount() const {
+ Instruction *CmpI = &Cond->front();
+ assert(isa<CmpInst>(CmpI) && "First inst must compare IV with TripCount");
+ return CmpI->getOperand(1);
+ }
+
+ /// Returns the instruction representing the current logical induction
+ /// variable. Always unsigned, always starting at 0 with an increment of one.
+ Instruction *getIndVar() const {
+ Instruction *IndVarPHI = &Header->front();
+ assert(isa<PHINode>(IndVarPHI) && "First inst must be the IV PHI");
+ return IndVarPHI;
+ }
+
+ /// Return the insertion point for user code in the body.
+ OpenMPIRBuilder::InsertPointTy getBodyIP() const {
+ return {Body, Body->begin()};
+ };
+
+ /// Return the insertion point for user code after the loop.
+ OpenMPIRBuilder::InsertPointTy getAfterIP() const {
+ return {After, After->begin()};
+ };
+
+ /// Consistency self-check.
+ void assertOK() const;
+};
+
+} // end namespace llvm
+
+#endif // LLVM_IR_IRBUILDER_H
diff --git a/linux-x64/clang/include/llvm/Frontend/OpenMP/OMPKinds.def b/linux-x64/clang/include/llvm/Frontend/OpenMP/OMPKinds.def
new file mode 100644
index 0000000..38496d3
--- /dev/null
+++ b/linux-x64/clang/include/llvm/Frontend/OpenMP/OMPKinds.def
@@ -0,0 +1,1141 @@
+//===--- OMPKinds.def - OpenMP directives, clauses, rt-calls -*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+/// \file
+///
+/// This file defines the list of supported OpenMP runtime
+/// calls, and other things that need to be listed in enums.
+///
+/// This file is under transition to OMP.td with TableGen code generation.
+///
+//===----------------------------------------------------------------------===//
+
+/// OpenMP Directives, combined directives and Clauses
+/// - Moved to OMP.td
+
+/// Types used in runtime structs or runtime functions
+///
+///{
+
+#ifndef OMP_TYPE
+#define OMP_TYPE(VarName, InitValue)
+#endif
+
+#define __OMP_TYPE(VarName) OMP_TYPE(VarName, Type::get##VarName##Ty(Ctx))
+
+__OMP_TYPE(Void)
+__OMP_TYPE(Int1)
+__OMP_TYPE(Int8)
+__OMP_TYPE(Int16)
+__OMP_TYPE(Int32)
+__OMP_TYPE(Int64)
+__OMP_TYPE(Int8Ptr)
+__OMP_TYPE(Int16Ptr)
+__OMP_TYPE(Int32Ptr)
+__OMP_TYPE(Int64Ptr)
+
+OMP_TYPE(SizeTy, M.getDataLayout().getIntPtrType(Ctx))
+OMP_TYPE(LanemaskTy, getLanemaskType())
+
+#define __OMP_PTR_TYPE(NAME, BASE) OMP_TYPE(NAME, BASE->getPointerTo())
+
+__OMP_PTR_TYPE(VoidPtr, Int8)
+__OMP_PTR_TYPE(VoidPtrPtr, VoidPtr)
+__OMP_PTR_TYPE(VoidPtrPtrPtr, VoidPtrPtr)
+
+__OMP_PTR_TYPE(Int8PtrPtr, Int8Ptr)
+__OMP_PTR_TYPE(Int8PtrPtrPtr, Int8PtrPtr)
+
+#undef __OMP_PTR_TYPE
+
+#undef __OMP_TYPE
+#undef OMP_TYPE
+
+///}
+
+/// array types
+///
+///{
+
+#ifndef OMP_ARRAY_TYPE
+#define OMP_ARRAY_TYPE(VarName, ElemTy, ArraySize)
+#endif
+
+#define __OMP_ARRAY_TYPE(VarName, ElemTy, ArraySize) \
+ OMP_ARRAY_TYPE(VarName, ElemTy, ArraySize)
+
+__OMP_ARRAY_TYPE(KmpCriticalName, Int32, 8)
+
+#undef __OMP_ARRAY_TYPE
+#undef OMP_ARRAY_TYPE
+
+///}
+
+/// Struct and function types
+///
+///{
+
+#ifndef OMP_STRUCT_TYPE
+#define OMP_STRUCT_TYPE(VarName, StructName, ...)
+#endif
+
+#define __OMP_STRUCT_TYPE(VarName, Name, ...) \
+ OMP_STRUCT_TYPE(VarName, "struct." #Name, __VA_ARGS__)
+
+__OMP_STRUCT_TYPE(Ident, ident_t, Int32, Int32, Int32, Int32, Int8Ptr)
+__OMP_STRUCT_TYPE(AsyncInfo, __tgt_async_info, Int8Ptr)
+
+#undef __OMP_STRUCT_TYPE
+#undef OMP_STRUCT_TYPE
+
+#ifndef OMP_FUNCTION_TYPE
+#define OMP_FUNCTION_TYPE(VarName, IsVarArg, ReturnType, ...)
+#endif
+
+#define __OMP_FUNCTION_TYPE(VarName, IsVarArg, ReturnType, ...) \
+ OMP_FUNCTION_TYPE(VarName, IsVarArg, ReturnType, __VA_ARGS__)
+
+__OMP_FUNCTION_TYPE(ParallelTask, true, Void, Int32Ptr, Int32Ptr)
+__OMP_FUNCTION_TYPE(ReduceFunction, false, Void, VoidPtr, VoidPtr)
+__OMP_FUNCTION_TYPE(CopyFunction, false, Void, VoidPtr, VoidPtr)
+__OMP_FUNCTION_TYPE(KmpcCtor, false, VoidPtr, VoidPtr)
+__OMP_FUNCTION_TYPE(KmpcDtor, false, Void, VoidPtr)
+__OMP_FUNCTION_TYPE(KmpcCopyCtor, false, VoidPtr, VoidPtr, VoidPtr)
+__OMP_FUNCTION_TYPE(TaskRoutineEntry, false, Int32, Int32,
+ /* kmp_task_t */ VoidPtr)
+__OMP_FUNCTION_TYPE(ShuffleReduce, false, Void, VoidPtr, Int16, Int16, Int16)
+__OMP_FUNCTION_TYPE(InterWarpCopy, false, Void, VoidPtr, Int32)
+__OMP_FUNCTION_TYPE(GlobalList, false, Void, VoidPtr, Int32, VoidPtr)
+
+#undef __OMP_FUNCTION_TYPE
+#undef OMP_FUNCTION_TYPE
+
+///}
+
+/// Internal Control Variables information
+///
+///{
+
+#ifndef ICV_INIT_VALUE
+#define ICV_INIT_VALUE(Enum, Name)
+#endif
+
+#define __ICV_INIT_VALUE(Name) ICV_INIT_VALUE(ICV_##Name, #Name)
+
+__ICV_INIT_VALUE(ZERO)
+__ICV_INIT_VALUE(FALSE)
+__ICV_INIT_VALUE(IMPLEMENTATION_DEFINED)
+__ICV_INIT_VALUE(LAST)
+
+#undef __ICV_INIT_VALUE
+#undef ICV_INIT_VALUE
+
+#ifndef ICV_DATA_ENV
+#define ICV_DATA_ENV(Enum, Name, EnvVarName, Init)
+#endif
+
+#define __ICV_DATA_ENV(Name, EnvVarName, Init) \
+ ICV_DATA_ENV(ICV_##Name, #Name, #EnvVarName, Init)
+
+__ICV_DATA_ENV(nthreads, OMP_NUM_THREADS, ICV_IMPLEMENTATION_DEFINED)
+__ICV_DATA_ENV(active_levels, NONE, ICV_ZERO)
+__ICV_DATA_ENV(cancel, OMP_CANCELLATION, ICV_FALSE)
+__ICV_DATA_ENV(proc_bind, OMP_PROC_BIND, ICV_IMPLEMENTATION_DEFINED)
+__ICV_DATA_ENV(__last, last, ICV_LAST)
+
+#undef __ICV_DATA_ENV
+#undef ICV_DATA_ENV
+
+#ifndef ICV_RT_SET
+#define ICV_RT_SET(Name, RTL)
+#endif
+
+#define __ICV_RT_SET(Name, RTL) ICV_RT_SET(ICV_##Name, OMPRTL_##RTL)
+
+__ICV_RT_SET(nthreads, omp_set_num_threads)
+
+#undef __ICV_RT_SET
+#undef ICV_RT_SET
+
+#ifndef ICV_RT_GET
+#define ICV_RT_GET(Name, RTL)
+#endif
+
+#define __ICV_RT_GET(Name, RTL) ICV_RT_GET(ICV_##Name, OMPRTL_##RTL)
+
+__ICV_RT_GET(nthreads, omp_get_max_threads)
+__ICV_RT_GET(active_levels, omp_get_active_level)
+__ICV_RT_GET(cancel, omp_get_cancellation)
+__ICV_RT_GET(proc_bind, omp_get_proc_bind)
+
+#undef __ICV_RT_GET
+#undef ICV_RT_GET
+
+///}
+
+/// Runtime library function (and their attributes)
+///
+///{
+
+#ifndef OMP_RTL
+#define OMP_RTL(Enum, Str, IsVarArg, ReturnType, ...)
+#endif
+
+#define __OMP_RTL(Name, IsVarArg, ReturnType, ...) \
+ OMP_RTL(OMPRTL_##Name, #Name, IsVarArg, ReturnType, __VA_ARGS__)
+
+
+
+__OMP_RTL(__kmpc_barrier, false, Void, IdentPtr, Int32)
+__OMP_RTL(__kmpc_cancel, false, Int32, IdentPtr, Int32, Int32)
+__OMP_RTL(__kmpc_cancel_barrier, false, Int32, IdentPtr, Int32)
+__OMP_RTL(__kmpc_flush, false, Void, IdentPtr)
+__OMP_RTL(__kmpc_global_thread_num, false, Int32, IdentPtr)
+__OMP_RTL(__kmpc_fork_call, true, Void, IdentPtr, Int32, ParallelTaskPtr)
+__OMP_RTL(__kmpc_omp_taskwait, false, Int32, IdentPtr, Int32)
+__OMP_RTL(__kmpc_omp_taskyield, false, Int32, IdentPtr, Int32, /* Int */ Int32)
+__OMP_RTL(__kmpc_push_num_threads, false, Void, IdentPtr, Int32,
+ /* Int */ Int32)
+__OMP_RTL(__kmpc_push_proc_bind, false, Void, IdentPtr, Int32, /* Int */ Int32)
+__OMP_RTL(__kmpc_omp_reg_task_with_affinity, false, Int32, IdentPtr, Int32,
+ /* kmp_task_t */ VoidPtr, Int32,
+ /* kmp_task_affinity_info_t */ VoidPtr)
+
+__OMP_RTL(omp_get_thread_num, false, Int32, )
+__OMP_RTL(omp_get_num_threads, false, Int32, )
+__OMP_RTL(omp_get_max_threads, false, Int32, )
+__OMP_RTL(omp_in_parallel, false, Int32, )
+__OMP_RTL(omp_get_dynamic, false, Int32, )
+__OMP_RTL(omp_get_cancellation, false, Int32, )
+__OMP_RTL(omp_get_nested, false, Int32, )
+__OMP_RTL(omp_get_schedule, false, Void, Int32Ptr, Int32Ptr)
+__OMP_RTL(omp_get_thread_limit, false, Int32, )
+__OMP_RTL(omp_get_supported_active_levels, false, Int32, )
+__OMP_RTL(omp_get_max_active_levels, false, Int32, )
+__OMP_RTL(omp_get_level, false, Int32, )
+__OMP_RTL(omp_get_ancestor_thread_num, false, Int32, Int32)
+__OMP_RTL(omp_get_team_size, false, Int32, Int32)
+__OMP_RTL(omp_get_active_level, false, Int32, )
+__OMP_RTL(omp_in_final, false, Int32, )
+__OMP_RTL(omp_get_proc_bind, false, Int32, )
+__OMP_RTL(omp_get_num_places, false, Int32, )
+__OMP_RTL(omp_get_num_procs, false, Int32, )
+__OMP_RTL(omp_get_place_proc_ids, false, Void, Int32, Int32Ptr)
+__OMP_RTL(omp_get_place_num, false, Int32, )
+__OMP_RTL(omp_get_partition_num_places, false, Int32, )
+__OMP_RTL(omp_get_partition_place_nums, false, Void, Int32Ptr)
+
+__OMP_RTL(omp_set_num_threads, false, Void, Int32)
+__OMP_RTL(omp_set_dynamic, false, Void, Int32)
+__OMP_RTL(omp_set_nested, false, Void, Int32)
+__OMP_RTL(omp_set_schedule, false, Void, Int32, Int32)
+__OMP_RTL(omp_set_max_active_levels, false, Void, Int32)
+
+__OMP_RTL(__kmpc_master, false, Int32, IdentPtr, Int32)
+__OMP_RTL(__kmpc_end_master, false, Void, IdentPtr, Int32)
+__OMP_RTL(__kmpc_critical, false, Void, IdentPtr, Int32, KmpCriticalNamePtrTy)
+__OMP_RTL(__kmpc_critical_with_hint, false, Void, IdentPtr, Int32,
+ KmpCriticalNamePtrTy, Int32)
+__OMP_RTL(__kmpc_end_critical, false, Void, IdentPtr, Int32,
+ KmpCriticalNamePtrTy)
+
+__OMP_RTL(__kmpc_begin, false, Void, IdentPtr, Int32)
+__OMP_RTL(__kmpc_end, false, Void, IdentPtr)
+
+__OMP_RTL(__kmpc_reduce, false, Int32, IdentPtr, Int32, Int32, SizeTy, VoidPtr,
+ ReduceFunctionPtr, KmpCriticalNamePtrTy)
+__OMP_RTL(__kmpc_reduce_nowait, false, Int32, IdentPtr, Int32, Int32, SizeTy,
+ VoidPtr, ReduceFunctionPtr, KmpCriticalNamePtrTy)
+__OMP_RTL(__kmpc_end_reduce, false, Void, IdentPtr, Int32, KmpCriticalNamePtrTy)
+__OMP_RTL(__kmpc_end_reduce_nowait, false, Void, IdentPtr, Int32,
+ KmpCriticalNamePtrTy)
+
+__OMP_RTL(__kmpc_ordered, false, Void, IdentPtr, Int32)
+__OMP_RTL(__kmpc_end_ordered, false, Void, IdentPtr, Int32)
+
+__OMP_RTL(__kmpc_for_static_init_4, false, Void, IdentPtr, Int32, Int32,
+ Int32Ptr, Int32Ptr, Int32Ptr, Int32Ptr, Int32, Int32)
+__OMP_RTL(__kmpc_for_static_init_4u, false, Void, IdentPtr, Int32, Int32,
+ Int32Ptr, Int32Ptr, Int32Ptr, Int32Ptr, Int32, Int32)
+__OMP_RTL(__kmpc_for_static_init_8, false, Void, IdentPtr, Int32, Int32,
+ Int32Ptr, Int64Ptr, Int64Ptr, Int64Ptr, Int64, Int64)
+__OMP_RTL(__kmpc_for_static_init_8u, false, Void, IdentPtr, Int32, Int32,
+ Int32Ptr, Int64Ptr, Int64Ptr, Int64Ptr, Int64, Int64)
+__OMP_RTL(__kmpc_for_static_fini, false, Void, IdentPtr, Int32)
+__OMP_RTL(__kmpc_dist_dispatch_init_4, false, Void, IdentPtr, Int32, Int32,
+ Int32Ptr, Int32, Int32, Int32, Int32)
+__OMP_RTL(__kmpc_dist_dispatch_init_4u, false, Void, IdentPtr, Int32, Int32,
+ Int32Ptr, Int32, Int32, Int32, Int32)
+__OMP_RTL(__kmpc_dist_dispatch_init_8, false, Void, IdentPtr, Int32, Int32,
+ Int32Ptr, Int64, Int64, Int64, Int64)
+__OMP_RTL(__kmpc_dist_dispatch_init_8u, false, Void, IdentPtr, Int32, Int32,
+ Int32Ptr, Int64, Int64, Int64, Int64)
+__OMP_RTL(__kmpc_dispatch_init_4, false, Void, IdentPtr, Int32, Int32, Int32,
+ Int32, Int32, Int32)
+__OMP_RTL(__kmpc_dispatch_init_4u, false, Void, IdentPtr, Int32, Int32, Int32,
+ Int32, Int32, Int32)
+__OMP_RTL(__kmpc_dispatch_init_8, false, Void, IdentPtr, Int32, Int32, Int64,
+ Int64, Int64, Int64)
+__OMP_RTL(__kmpc_dispatch_init_8u, false, Void, IdentPtr, Int32, Int32, Int64,
+ Int64, Int64, Int64)
+__OMP_RTL(__kmpc_dispatch_next_4, false, Int32, IdentPtr, Int32, Int32Ptr,
+ Int32Ptr, Int32Ptr, Int32Ptr)
+__OMP_RTL(__kmpc_dispatch_next_4u, false, Int32, IdentPtr, Int32, Int32Ptr,
+ Int32Ptr, Int32Ptr, Int32Ptr)
+__OMP_RTL(__kmpc_dispatch_next_8, false, Int32, IdentPtr, Int32, Int32Ptr,
+ Int64Ptr, Int64Ptr, Int64Ptr)
+__OMP_RTL(__kmpc_dispatch_next_8u, false, Int32, IdentPtr, Int32, Int32Ptr,
+ Int64Ptr, Int64Ptr, Int64Ptr)
+__OMP_RTL(__kmpc_dispatch_fini_4, false, Void, IdentPtr, Int32)
+__OMP_RTL(__kmpc_dispatch_fini_4u, false, Void, IdentPtr, Int32)
+__OMP_RTL(__kmpc_dispatch_fini_8, false, Void, IdentPtr, Int32)
+__OMP_RTL(__kmpc_dispatch_fini_8u, false, Void, IdentPtr, Int32)
+__OMP_RTL(__kmpc_team_static_init_4, false, Void, IdentPtr, Int32, Int32Ptr,
+ Int32Ptr, Int32Ptr, Int32Ptr, Int32, Int32)
+__OMP_RTL(__kmpc_team_static_init_4u, false, Void, IdentPtr, Int32, Int32Ptr,
+ Int32Ptr, Int32Ptr, Int32Ptr, Int32, Int32)
+__OMP_RTL(__kmpc_team_static_init_8, false, Void, IdentPtr, Int32, Int32Ptr,
+ Int64Ptr, Int64Ptr, Int64Ptr, Int64, Int64)
+__OMP_RTL(__kmpc_team_static_init_8u, false, Void, IdentPtr, Int32, Int32Ptr,
+ Int64Ptr, Int64Ptr, Int64Ptr, Int64, Int64)
+__OMP_RTL(__kmpc_dist_for_static_init_4, false, Void, IdentPtr, Int32, Int32,
+ Int32Ptr, Int32Ptr, Int32Ptr, Int32Ptr, Int32Ptr, Int32, Int32)
+__OMP_RTL(__kmpc_dist_for_static_init_4u, false, Void, IdentPtr, Int32, Int32,
+ Int32Ptr, Int32Ptr, Int32Ptr, Int32Ptr, Int32Ptr, Int32, Int32)
+__OMP_RTL(__kmpc_dist_for_static_init_8, false, Void, IdentPtr, Int32, Int32,
+ Int32Ptr, Int64Ptr, Int64Ptr, Int64Ptr, Int64Ptr, Int64, Int64)
+__OMP_RTL(__kmpc_dist_for_static_init_8u, false, Void, IdentPtr, Int32, Int32,
+ Int32Ptr, Int64Ptr, Int64Ptr, Int64Ptr, Int64Ptr, Int64, Int64)
+
+__OMP_RTL(__kmpc_single, false, Int32, IdentPtr, Int32)
+__OMP_RTL(__kmpc_end_single, false, Void, IdentPtr, Int32)
+
+__OMP_RTL(__kmpc_omp_task_alloc, false, /* kmp_task_t */ VoidPtr, IdentPtr,
+ Int32, Int32, SizeTy, SizeTy, TaskRoutineEntryPtr)
+__OMP_RTL(__kmpc_omp_task, false, Int32, IdentPtr, Int32,
+ /* kmp_task_t */ VoidPtr)
+__OMP_RTL(__kmpc_end_taskgroup, false, Void, IdentPtr, Int32)
+__OMP_RTL(__kmpc_taskgroup, false, Void, IdentPtr, Int32)
+__OMP_RTL(__kmpc_omp_task_begin_if0, false, Void, IdentPtr, Int32,
+ /* kmp_task_t */ VoidPtr)
+__OMP_RTL(__kmpc_omp_task_complete_if0, false, Void, IdentPtr, Int32,
+ /* kmp_tasK_t */ VoidPtr)
+__OMP_RTL(__kmpc_omp_task_with_deps, false, Int32, IdentPtr, Int32,
+ /* kmp_task_t */ VoidPtr, Int32,
+ /* kmp_depend_info_t */ VoidPtr, Int32,
+ /* kmp_depend_info_t */ VoidPtr)
+__OMP_RTL(__kmpc_taskloop, false, Void, IdentPtr, /* Int */ Int32, VoidPtr,
+ /* Int */ Int32, Int64Ptr, Int64Ptr, Int64, /* Int */ Int32,
+ /* Int */ Int32, Int64, VoidPtr)
+__OMP_RTL(__kmpc_omp_target_task_alloc, false, /* kmp_task_t */ VoidPtr,
+ IdentPtr, Int32, Int32, SizeTy, SizeTy, TaskRoutineEntryPtr, Int64)
+__OMP_RTL(__kmpc_taskred_modifier_init, false, /* kmp_taskgroup */ VoidPtr,
+ IdentPtr, /* Int */ Int32, /* Int */ Int32, /* Int */ Int32, VoidPtr)
+__OMP_RTL(__kmpc_taskred_init, false, /* kmp_taskgroup */ VoidPtr,
+ /* Int */ Int32, /* Int */ Int32, VoidPtr)
+__OMP_RTL(__kmpc_task_reduction_modifier_fini, false, Void, IdentPtr,
+ /* Int */ Int32, /* Int */ Int32)
+__OMP_RTL(__kmpc_task_reduction_get_th_data, false, VoidPtr, Int32, VoidPtr,
+ VoidPtr)
+__OMP_RTL(__kmpc_task_reduction_init, false, VoidPtr, Int32, Int32, VoidPtr)
+__OMP_RTL(__kmpc_task_reduction_modifier_init, false, VoidPtr, VoidPtr, Int32,
+ Int32, Int32, VoidPtr)
+__OMP_RTL(__kmpc_proxy_task_completed_ooo, false, Void, VoidPtr)
+
+__OMP_RTL(__kmpc_omp_wait_deps, false, Void, IdentPtr, Int32, Int32,
+ /* kmp_depend_info_t */ VoidPtr, Int32, VoidPtr)
+__OMP_RTL(__kmpc_cancellationpoint, false, Int32, IdentPtr, Int32, Int32)
+
+__OMP_RTL(__kmpc_fork_teams, true, Void, IdentPtr, Int32, ParallelTaskPtr)
+__OMP_RTL(__kmpc_push_num_teams, false, Void, IdentPtr, Int32, Int32, Int32)
+
+__OMP_RTL(__kmpc_copyprivate, false, Void, IdentPtr, Int32, SizeTy, VoidPtr,
+ CopyFunctionPtr, Int32)
+__OMP_RTL(__kmpc_threadprivate_cached, false, VoidPtr, IdentPtr, Int32, VoidPtr,
+ SizeTy, VoidPtrPtrPtr)
+__OMP_RTL(__kmpc_threadprivate_register, false, Void, IdentPtr, VoidPtr,
+ KmpcCtorPtr, KmpcCopyCtorPtr, KmpcDtorPtr)
+
+__OMP_RTL(__kmpc_doacross_init, false, Void, IdentPtr, Int32, Int32,
+ /* kmp_dim */ VoidPtr)
+__OMP_RTL(__kmpc_doacross_post, false, Void, IdentPtr, Int32, Int64Ptr)
+__OMP_RTL(__kmpc_doacross_wait, false, Void, IdentPtr, Int32, Int64Ptr)
+__OMP_RTL(__kmpc_doacross_fini, false, Void, IdentPtr, Int32)
+
+__OMP_RTL(__kmpc_alloc, false, VoidPtr, /* Int */ Int32, SizeTy, VoidPtr)
+__OMP_RTL(__kmpc_free, false, Void, /* Int */ Int32, VoidPtr, VoidPtr)
+
+__OMP_RTL(__kmpc_init_allocator, false, /* omp_allocator_handle_t */ VoidPtr,
+ /* Int */ Int32, /* omp_memespace_handle_t */ VoidPtr,
+ /* Int */ Int32, /* omp_alloctrait_t */ VoidPtr)
+__OMP_RTL(__kmpc_destroy_allocator, false, Void, /* Int */ Int32,
+ /* omp_allocator_handle_t */ VoidPtr)
+
+__OMP_RTL(__kmpc_push_target_tripcount, false, Void, IdentPtr, Int64, Int64)
+__OMP_RTL(__tgt_target_mapper, false, Int32, IdentPtr, Int64, VoidPtr, Int32, VoidPtrPtr,
+ VoidPtrPtr, Int64Ptr, Int64Ptr, VoidPtrPtr, VoidPtrPtr)
+__OMP_RTL(__tgt_target_nowait_mapper, false, Int32, IdentPtr, Int64, VoidPtr, Int32,
+ VoidPtrPtr, VoidPtrPtr, Int64Ptr, Int64Ptr, VoidPtrPtr, VoidPtrPtr)
+__OMP_RTL(__tgt_target_teams_mapper, false, Int32, IdentPtr, Int64, VoidPtr, Int32,
+ VoidPtrPtr, VoidPtrPtr, Int64Ptr, Int64Ptr, VoidPtrPtr, VoidPtrPtr, Int32, Int32)
+__OMP_RTL(__tgt_target_teams_nowait_mapper, false, Int32, IdentPtr, Int64, VoidPtr, Int32,
+ VoidPtrPtr, VoidPtrPtr, Int64Ptr, Int64Ptr, VoidPtrPtr, VoidPtrPtr, Int32, Int32)
+__OMP_RTL(__tgt_register_requires, false, Void, Int64)
+__OMP_RTL(__tgt_target_data_begin_mapper, false, Void, IdentPtr, Int64, Int32, VoidPtrPtr,
+ VoidPtrPtr, Int64Ptr, Int64Ptr, VoidPtrPtr, VoidPtrPtr)
+__OMP_RTL(__tgt_target_data_begin_nowait_mapper, false, Void, IdentPtr, Int64, Int32,
+ VoidPtrPtr, VoidPtrPtr, Int64Ptr, Int64Ptr, VoidPtrPtr, VoidPtrPtr)
+__OMP_RTL(__tgt_target_data_begin_mapper_issue, false, Void, IdentPtr, Int64, Int32,
+ VoidPtrPtr, VoidPtrPtr, Int64Ptr, Int64Ptr, VoidPtrPtr, VoidPtrPtr, AsyncInfoPtr)
+__OMP_RTL(__tgt_target_data_begin_mapper_wait, false, Void, Int64, AsyncInfoPtr)
+__OMP_RTL(__tgt_target_data_end_mapper, false, Void, IdentPtr, Int64, Int32, VoidPtrPtr,
+ VoidPtrPtr, Int64Ptr, Int64Ptr, VoidPtrPtr, VoidPtrPtr)
+__OMP_RTL(__tgt_target_data_end_nowait_mapper, false, Void, IdentPtr, Int64, Int32,
+ VoidPtrPtr, VoidPtrPtr, Int64Ptr, Int64Ptr, VoidPtrPtr, VoidPtrPtr)
+__OMP_RTL(__tgt_target_data_update_mapper, false, Void, IdentPtr, Int64, Int32,
+ VoidPtrPtr, VoidPtrPtr, Int64Ptr, Int64Ptr, VoidPtrPtr, VoidPtrPtr)
+__OMP_RTL(__tgt_target_data_update_nowait_mapper, false, Void, IdentPtr, Int64, Int32,
+ VoidPtrPtr, VoidPtrPtr, Int64Ptr, Int64Ptr, VoidPtrPtr, VoidPtrPtr)
+__OMP_RTL(__tgt_mapper_num_components, false, Int64, VoidPtr)
+__OMP_RTL(__tgt_push_mapper_component, false, Void, VoidPtr, VoidPtr, VoidPtr,
+ Int64, Int64)
+__OMP_RTL(__kmpc_task_allow_completion_event, false, VoidPtr, IdentPtr,
+ /* Int */ Int32, /* kmp_task_t */ VoidPtr)
+
+/// OpenMP Device runtime functions
+__OMP_RTL(__kmpc_kernel_init, false, Void, Int32, Int16)
+__OMP_RTL(__kmpc_kernel_deinit, false, Void, Int16)
+__OMP_RTL(__kmpc_spmd_kernel_init, false, Void, Int32, Int16)
+__OMP_RTL(__kmpc_spmd_kernel_deinit_v2, false, Void, Int16)
+__OMP_RTL(__kmpc_kernel_prepare_parallel, false, Void, VoidPtr)
+__OMP_RTL(__kmpc_kernel_parallel, false, Int1, VoidPtrPtr)
+__OMP_RTL(__kmpc_kernel_end_parallel, false, Void, )
+__OMP_RTL(__kmpc_serialized_parallel, false, Void, IdentPtr, Int32)
+__OMP_RTL(__kmpc_end_serialized_parallel, false, Void, IdentPtr, Int32)
+__OMP_RTL(__kmpc_shuffle_int32, false, Int32, Int32, Int16, Int16)
+__OMP_RTL(__kmpc_nvptx_parallel_reduce_nowait_v2, false, Int32, IdentPtr, Int32,
+ Int32, SizeTy, VoidPtr, ShuffleReducePtr, InterWarpCopyPtr)
+__OMP_RTL(__kmpc_nvptx_end_reduce_nowait, false, Void, Int32)
+__OMP_RTL(__kmpc_nvptx_teams_reduce_nowait_v2, false, Int32, IdentPtr, Int32,
+ VoidPtr, Int32, VoidPtr, ShuffleReducePtr, InterWarpCopyPtr,
+ GlobalListPtr, GlobalListPtr, GlobalListPtr, GlobalListPtr)
+
+__OMP_RTL(__kmpc_shuffle_int64, false, Int64, Int64, Int16, Int16)
+__OMP_RTL(__kmpc_data_sharing_init_stack, false, Void, )
+__OMP_RTL(__kmpc_data_sharing_init_stack_spmd, false, Void, )
+
+__OMP_RTL(__kmpc_data_sharing_coalesced_push_stack, false, VoidPtr, SizeTy, Int16)
+__OMP_RTL(__kmpc_data_sharing_push_stack, false, VoidPtr, SizeTy, Int16)
+__OMP_RTL(__kmpc_data_sharing_pop_stack, false, Void, VoidPtr)
+__OMP_RTL(__kmpc_begin_sharing_variables, false, Void, VoidPtrPtrPtr, SizeTy)
+__OMP_RTL(__kmpc_end_sharing_variables, false, Void, )
+__OMP_RTL(__kmpc_get_shared_variables, false, Void, VoidPtrPtrPtr)
+__OMP_RTL(__kmpc_parallel_level, false, Int16, IdentPtr, Int32)
+__OMP_RTL(__kmpc_is_spmd_exec_mode, false, Int8, )
+__OMP_RTL(__kmpc_get_team_static_memory, false, Void, Int16, VoidPtr, SizeTy,
+ Int16, VoidPtrPtr)
+__OMP_RTL(__kmpc_restore_team_static_memory, false, Void, Int16, Int16)
+__OMP_RTL(__kmpc_barrier_simple_spmd, false, Void, IdentPtr, Int32)
+
+__OMP_RTL(__kmpc_warp_active_thread_mask, false, LanemaskTy,)
+__OMP_RTL(__kmpc_syncwarp, false, Void, LanemaskTy)
+
+__OMP_RTL(__last, false, Void, )
+
+#undef __OMP_RTL
+#undef OMP_RTL
+
+#define ParamAttrs(...) ArrayRef<AttributeSet>({__VA_ARGS__})
+#define EnumAttr(Kind) Attribute::get(Ctx, Attribute::AttrKind::Kind)
+#define EnumAttrInt(Kind, N) Attribute::get(Ctx, Attribute::AttrKind::Kind, N)
+#define AttributeSet(...) \
+ AttributeSet::get(Ctx, ArrayRef<Attribute>({__VA_ARGS__}))
+
+#ifndef OMP_ATTRS_SET
+#define OMP_ATTRS_SET(VarName, AttrSet)
+#endif
+
+#define __OMP_ATTRS_SET(VarName, AttrSet) OMP_ATTRS_SET(VarName, AttrSet)
+
+__OMP_ATTRS_SET(GetterAttrs,
+ OptimisticAttributes
+ ? AttributeSet(EnumAttr(NoUnwind), EnumAttr(ReadOnly),
+ EnumAttr(NoSync), EnumAttr(NoFree),
+ EnumAttr(InaccessibleMemOnly),
+ EnumAttr(WillReturn))
+ : AttributeSet(EnumAttr(NoUnwind)))
+__OMP_ATTRS_SET(GetterArgWriteAttrs,
+ OptimisticAttributes
+ ? AttributeSet(EnumAttr(NoUnwind), EnumAttr(NoSync),
+ EnumAttr(NoFree),
+ EnumAttr(InaccessibleMemOrArgMemOnly),
+ EnumAttr(WillReturn))
+ : AttributeSet(EnumAttr(NoUnwind)))
+__OMP_ATTRS_SET(SetterAttrs,
+ OptimisticAttributes
+ ? AttributeSet(EnumAttr(NoUnwind), EnumAttr(WriteOnly),
+ EnumAttr(NoSync), EnumAttr(NoFree),
+ EnumAttr(InaccessibleMemOnly),
+ EnumAttr(WillReturn))
+ : AttributeSet(EnumAttr(NoUnwind)))
+
+__OMP_ATTRS_SET(DefaultAttrs,
+ OptimisticAttributes
+ ? AttributeSet(EnumAttr(NoUnwind), EnumAttr(NoSync),
+ EnumAttr(WillReturn), EnumAttr(NoFree))
+ : AttributeSet(EnumAttr(NoUnwind)))
+
+__OMP_ATTRS_SET(BarrierAttrs,
+ OptimisticAttributes
+ ? AttributeSet(EnumAttr(NoUnwind), EnumAttr(Convergent))
+ : AttributeSet(EnumAttr(NoUnwind), EnumAttr(Convergent)))
+
+__OMP_ATTRS_SET(InaccessibleArgOnlyAttrs,
+ OptimisticAttributes
+ ? AttributeSet(EnumAttr(NoUnwind), EnumAttr(NoSync),
+ EnumAttr(InaccessibleMemOrArgMemOnly),
+ EnumAttr(WillReturn), EnumAttr(NoFree))
+ : AttributeSet(EnumAttr(NoUnwind)))
+
+#if 0
+__OMP_ATTRS_SET(InaccessibleOnlyAttrs,
+ OptimisticAttributes
+ ? AttributeSet(EnumAttr(NoUnwind), EnumAttr(NoSync),
+ EnumAttr(InaccessibleMemOnly),
+ EnumAttr(WillReturn), EnumAttr(NoFree))
+ : AttributeSet(EnumAttr(NoUnwind)))
+#endif
+
+__OMP_ATTRS_SET(AllocAttrs,
+ OptimisticAttributes
+ ? AttributeSet(EnumAttr(NoUnwind), EnumAttr(NoSync),
+ EnumAttr(WillReturn))
+ : AttributeSet(EnumAttr(NoUnwind)))
+
+__OMP_ATTRS_SET(ForkAttrs, OptimisticAttributes
+ ? AttributeSet(EnumAttr(NoUnwind))
+ : AttributeSet(EnumAttr(NoUnwind)))
+
+__OMP_ATTRS_SET(ReadOnlyPtrAttrs,
+ OptimisticAttributes
+ ? AttributeSet(EnumAttr(ReadOnly), EnumAttr(NoFree),
+ EnumAttr(NoCapture))
+ : AttributeSet())
+
+#if 0
+__OMP_ATTRS_SET(WriteOnlyPtrAttrs,
+ OptimisticAttributes
+ ? AttributeSet(EnumAttr(WriteOnly), EnumAttr(NoFree),
+ EnumAttr(NoCapture))
+ : AttributeSet())
+#endif
+
+__OMP_ATTRS_SET(ArgPtrAttrs,
+ OptimisticAttributes
+ ? AttributeSet(EnumAttr(NoCapture), EnumAttr(NoFree))
+ : AttributeSet())
+
+__OMP_ATTRS_SET(ReturnPtrAttrs,
+ OptimisticAttributes
+ ? AttributeSet(EnumAttr(NoAlias))
+ : AttributeSet())
+
+#if 0
+__OMP_ATTRS_SET(ReturnAlignedPtrAttrs,
+ OptimisticAttributes
+ ? AttributeSet(EnumAttr(NoAlias), EnumAttrInt(Alignment, 8),
+ EnumAttrInt(DereferenceableOrNull, 8))
+ : AttributeSet())
+#endif
+
+#undef __OMP_ATTRS_SET
+#undef OMP_ATTRS_SET
+
+#ifndef OMP_RTL_ATTRS
+#define OMP_RTL_ATTRS(Enum, FnAttrSet, RetAttrSet, ArgAttrSets)
+#endif
+
+#define __OMP_RTL_ATTRS(Name, FnAttrSet, RetAttrSet, ArgAttrSets) \
+ OMP_RTL_ATTRS(OMPRTL_##Name, FnAttrSet, RetAttrSet, ArgAttrSets)
+
+__OMP_RTL_ATTRS(__kmpc_barrier, BarrierAttrs, AttributeSet(),
+ ParamAttrs(ReadOnlyPtrAttrs))
+__OMP_RTL_ATTRS(__kmpc_barrier_simple_spmd, BarrierAttrs, AttributeSet(),
+ ParamAttrs(ReadOnlyPtrAttrs))
+__OMP_RTL_ATTRS(__kmpc_warp_active_thread_mask, BarrierAttrs, AttributeSet(),
+ ParamAttrs())
+__OMP_RTL_ATTRS(__kmpc_syncwarp, BarrierAttrs, AttributeSet(), ParamAttrs())
+__OMP_RTL_ATTRS(__kmpc_cancel, InaccessibleArgOnlyAttrs, AttributeSet(),
+ ParamAttrs(ReadOnlyPtrAttrs))
+__OMP_RTL_ATTRS(__kmpc_cancel_barrier, BarrierAttrs, AttributeSet(),
+ ParamAttrs(ReadOnlyPtrAttrs))
+__OMP_RTL_ATTRS(__kmpc_flush, BarrierAttrs, AttributeSet(),
+ ParamAttrs(ReadOnlyPtrAttrs))
+__OMP_RTL_ATTRS(__kmpc_global_thread_num, GetterAttrs, AttributeSet(),
+ ParamAttrs(ReadOnlyPtrAttrs))
+__OMP_RTL_ATTRS(__kmpc_fork_call, ForkAttrs, AttributeSet(),
+ ParamAttrs(ReadOnlyPtrAttrs, AttributeSet(), ReadOnlyPtrAttrs))
+__OMP_RTL_ATTRS(__kmpc_omp_taskwait, BarrierAttrs, AttributeSet(),
+ ParamAttrs(ReadOnlyPtrAttrs))
+__OMP_RTL_ATTRS(__kmpc_omp_taskyield, InaccessibleArgOnlyAttrs, AttributeSet(),
+ ParamAttrs(ReadOnlyPtrAttrs))
+__OMP_RTL_ATTRS(__kmpc_push_num_threads, InaccessibleArgOnlyAttrs,
+ AttributeSet(), ParamAttrs(ReadOnlyPtrAttrs))
+__OMP_RTL_ATTRS(__kmpc_push_proc_bind, InaccessibleArgOnlyAttrs, AttributeSet(),
+ ParamAttrs(ReadOnlyPtrAttrs))
+__OMP_RTL_ATTRS(__kmpc_serialized_parallel, InaccessibleArgOnlyAttrs,
+ AttributeSet(), ParamAttrs(ReadOnlyPtrAttrs))
+__OMP_RTL_ATTRS(__kmpc_end_serialized_parallel, InaccessibleArgOnlyAttrs,
+ AttributeSet(), ParamAttrs(ReadOnlyPtrAttrs))
+__OMP_RTL_ATTRS(__kmpc_omp_reg_task_with_affinity, DefaultAttrs, AttributeSet(),
+ ParamAttrs(ReadOnlyPtrAttrs, AttributeSet(), ReadOnlyPtrAttrs,
+ AttributeSet(), ReadOnlyPtrAttrs))
+
+__OMP_RTL_ATTRS(omp_get_thread_num, GetterAttrs, AttributeSet(), ParamAttrs())
+__OMP_RTL_ATTRS(omp_get_num_threads, GetterAttrs, AttributeSet(), ParamAttrs())
+__OMP_RTL_ATTRS(omp_get_max_threads, GetterAttrs, AttributeSet(), ParamAttrs())
+__OMP_RTL_ATTRS(omp_in_parallel, GetterAttrs, AttributeSet(), ParamAttrs())
+__OMP_RTL_ATTRS(omp_get_dynamic, GetterAttrs, AttributeSet(), ParamAttrs())
+__OMP_RTL_ATTRS(omp_get_cancellation, GetterAttrs, AttributeSet(), ParamAttrs())
+__OMP_RTL_ATTRS(omp_get_nested, GetterAttrs, AttributeSet(), ParamAttrs())
+__OMP_RTL_ATTRS(
+ omp_get_schedule, GetterArgWriteAttrs, AttributeSet(),
+ ParamAttrs(AttributeSet(EnumAttr(NoCapture), EnumAttr(WriteOnly)),
+ AttributeSet(EnumAttr(NoCapture), EnumAttr(WriteOnly))))
+__OMP_RTL_ATTRS(omp_get_thread_limit, GetterAttrs, AttributeSet(), ParamAttrs())
+__OMP_RTL_ATTRS(omp_get_supported_active_levels, GetterAttrs, AttributeSet(),
+ ParamAttrs())
+__OMP_RTL_ATTRS(omp_get_max_active_levels, GetterAttrs, AttributeSet(),
+ ParamAttrs())
+__OMP_RTL_ATTRS(omp_get_level, GetterAttrs, AttributeSet(), ParamAttrs())
+__OMP_RTL_ATTRS(omp_get_ancestor_thread_num, GetterAttrs, AttributeSet(),
+ ParamAttrs())
+__OMP_RTL_ATTRS(omp_get_team_size, GetterAttrs, AttributeSet(), ParamAttrs())
+__OMP_RTL_ATTRS(omp_get_active_level, GetterAttrs, AttributeSet(), ParamAttrs())
+__OMP_RTL_ATTRS(omp_in_final, GetterAttrs, AttributeSet(), ParamAttrs())
+__OMP_RTL_ATTRS(omp_get_proc_bind, GetterAttrs, AttributeSet(), ParamAttrs())
+__OMP_RTL_ATTRS(omp_get_num_places, GetterAttrs, AttributeSet(), ParamAttrs())
+__OMP_RTL_ATTRS(omp_get_num_procs, GetterAttrs, AttributeSet(), ParamAttrs())
+__OMP_RTL_ATTRS(omp_get_place_proc_ids, GetterArgWriteAttrs, AttributeSet(),
+ ParamAttrs(AttributeSet(), AttributeSet(EnumAttr(NoCapture),
+ EnumAttr(WriteOnly))))
+__OMP_RTL_ATTRS(omp_get_place_num, GetterAttrs, AttributeSet(), ParamAttrs())
+__OMP_RTL_ATTRS(omp_get_partition_num_places, GetterAttrs, AttributeSet(),
+ ParamAttrs())
+__OMP_RTL_ATTRS(omp_get_partition_place_nums, GetterAttrs, AttributeSet(),
+ ParamAttrs())
+
+__OMP_RTL_ATTRS(omp_set_num_threads, SetterAttrs, AttributeSet(), ParamAttrs())
+__OMP_RTL_ATTRS(omp_set_dynamic, SetterAttrs, AttributeSet(), ParamAttrs())
+__OMP_RTL_ATTRS(omp_set_nested, SetterAttrs, AttributeSet(), ParamAttrs())
+__OMP_RTL_ATTRS(omp_set_schedule, SetterAttrs, AttributeSet(), ParamAttrs())
+__OMP_RTL_ATTRS(omp_set_max_active_levels, SetterAttrs, AttributeSet(),
+ ParamAttrs())
+
+__OMP_RTL_ATTRS(__kmpc_master, InaccessibleArgOnlyAttrs, AttributeSet(),
+ ParamAttrs(ReadOnlyPtrAttrs))
+__OMP_RTL_ATTRS(__kmpc_end_master, InaccessibleArgOnlyAttrs, AttributeSet(),
+ ParamAttrs(ReadOnlyPtrAttrs))
+__OMP_RTL_ATTRS(__kmpc_critical, BarrierAttrs, AttributeSet(),
+ ParamAttrs(ReadOnlyPtrAttrs, AttributeSet(), AttributeSet()))
+__OMP_RTL_ATTRS(__kmpc_critical_with_hint, BarrierAttrs, AttributeSet(),
+ ParamAttrs(ReadOnlyPtrAttrs, AttributeSet(), AttributeSet(),
+ AttributeSet()))
+__OMP_RTL_ATTRS(__kmpc_end_critical, BarrierAttrs, AttributeSet(),
+ ParamAttrs(ReadOnlyPtrAttrs, AttributeSet(), AttributeSet()))
+
+__OMP_RTL_ATTRS(__kmpc_begin, DefaultAttrs, AttributeSet(),
+ ParamAttrs(ReadOnlyPtrAttrs))
+__OMP_RTL_ATTRS(__kmpc_end, DefaultAttrs, AttributeSet(),
+ ParamAttrs(ReadOnlyPtrAttrs))
+
+__OMP_RTL_ATTRS(__kmpc_reduce, BarrierAttrs, AttributeSet(),
+ ParamAttrs(ReadOnlyPtrAttrs, AttributeSet(), AttributeSet(),
+ AttributeSet(), ReadOnlyPtrAttrs, AttributeSet()))
+__OMP_RTL_ATTRS(__kmpc_reduce_nowait, BarrierAttrs, AttributeSet(),
+ ParamAttrs(ReadOnlyPtrAttrs, AttributeSet(), AttributeSet(),
+ AttributeSet(), ReadOnlyPtrAttrs, AttributeSet()))
+__OMP_RTL_ATTRS(__kmpc_end_reduce, BarrierAttrs, AttributeSet(),
+ ParamAttrs(ReadOnlyPtrAttrs, AttributeSet(), AttributeSet()))
+__OMP_RTL_ATTRS(__kmpc_end_reduce_nowait, BarrierAttrs, AttributeSet(),
+ ParamAttrs(ReadOnlyPtrAttrs, AttributeSet(), AttributeSet()))
+
+__OMP_RTL_ATTRS(__kmpc_ordered, BarrierAttrs, AttributeSet(),
+ ParamAttrs(ReadOnlyPtrAttrs))
+__OMP_RTL_ATTRS(__kmpc_end_ordered, BarrierAttrs, AttributeSet(),
+ ParamAttrs(ReadOnlyPtrAttrs))
+
+__OMP_RTL_ATTRS(__kmpc_for_static_init_4, GetterArgWriteAttrs, AttributeSet(),
+ ParamAttrs(ReadOnlyPtrAttrs, AttributeSet(), AttributeSet(),
+ ArgPtrAttrs, ArgPtrAttrs, ArgPtrAttrs, ArgPtrAttrs,
+ AttributeSet(), AttributeSet()))
+__OMP_RTL_ATTRS(__kmpc_for_static_init_4u, GetterArgWriteAttrs, AttributeSet(),
+ ParamAttrs(ReadOnlyPtrAttrs, AttributeSet(), AttributeSet(),
+ ArgPtrAttrs, ArgPtrAttrs, ArgPtrAttrs, ArgPtrAttrs,
+ AttributeSet(), AttributeSet()))
+__OMP_RTL_ATTRS(__kmpc_for_static_init_8, GetterArgWriteAttrs, AttributeSet(),
+ ParamAttrs(ReadOnlyPtrAttrs, AttributeSet(), AttributeSet(),
+ ArgPtrAttrs, ArgPtrAttrs, ArgPtrAttrs, ArgPtrAttrs,
+ AttributeSet(), AttributeSet()))
+__OMP_RTL_ATTRS(__kmpc_for_static_init_8u, GetterArgWriteAttrs, AttributeSet(),
+ ParamAttrs(ReadOnlyPtrAttrs, AttributeSet(), AttributeSet(),
+ ArgPtrAttrs, ArgPtrAttrs, ArgPtrAttrs, ArgPtrAttrs,
+ AttributeSet(), AttributeSet()))
+__OMP_RTL_ATTRS(__kmpc_for_static_fini, InaccessibleArgOnlyAttrs,
+ AttributeSet(), ParamAttrs(ReadOnlyPtrAttrs))
+__OMP_RTL_ATTRS(__kmpc_dist_dispatch_init_4, GetterArgWriteAttrs,
+ AttributeSet(),
+ ParamAttrs(ReadOnlyPtrAttrs, AttributeSet(), AttributeSet(),
+ ArgPtrAttrs))
+__OMP_RTL_ATTRS(__kmpc_dist_dispatch_init_4u, GetterArgWriteAttrs,
+ AttributeSet(),
+ ParamAttrs(ReadOnlyPtrAttrs, AttributeSet(), AttributeSet(),
+ ArgPtrAttrs))
+__OMP_RTL_ATTRS(__kmpc_dist_dispatch_init_8, GetterArgWriteAttrs,
+ AttributeSet(),
+ ParamAttrs(ReadOnlyPtrAttrs, AttributeSet(), AttributeSet(),
+ ArgPtrAttrs))
+__OMP_RTL_ATTRS(__kmpc_dist_dispatch_init_8u, GetterArgWriteAttrs,
+ AttributeSet(),
+ ParamAttrs(ReadOnlyPtrAttrs, AttributeSet(), AttributeSet(),
+ ArgPtrAttrs))
+__OMP_RTL_ATTRS(__kmpc_dispatch_init_4, GetterArgWriteAttrs, AttributeSet(),
+ ParamAttrs(ReadOnlyPtrAttrs))
+__OMP_RTL_ATTRS(__kmpc_dispatch_init_4u, GetterArgWriteAttrs, AttributeSet(),
+ ParamAttrs(ReadOnlyPtrAttrs))
+__OMP_RTL_ATTRS(__kmpc_dispatch_init_8, GetterArgWriteAttrs, AttributeSet(),
+ ParamAttrs(ReadOnlyPtrAttrs))
+__OMP_RTL_ATTRS(__kmpc_dispatch_init_8u, GetterArgWriteAttrs, AttributeSet(),
+ ParamAttrs(ReadOnlyPtrAttrs))
+__OMP_RTL_ATTRS(__kmpc_dispatch_next_4, GetterArgWriteAttrs, AttributeSet(),
+ ParamAttrs(ReadOnlyPtrAttrs, AttributeSet(), ArgPtrAttrs,
+ ArgPtrAttrs, ArgPtrAttrs, ArgPtrAttrs))
+__OMP_RTL_ATTRS(__kmpc_dispatch_next_4u, GetterArgWriteAttrs, AttributeSet(),
+ ParamAttrs(ReadOnlyPtrAttrs, AttributeSet(), ArgPtrAttrs,
+ ArgPtrAttrs, ArgPtrAttrs, ArgPtrAttrs))
+__OMP_RTL_ATTRS(__kmpc_dispatch_next_8, GetterArgWriteAttrs, AttributeSet(),
+ ParamAttrs(ReadOnlyPtrAttrs, AttributeSet(), ArgPtrAttrs,
+ ArgPtrAttrs, ArgPtrAttrs, ArgPtrAttrs))
+__OMP_RTL_ATTRS(__kmpc_dispatch_next_8u, GetterArgWriteAttrs, AttributeSet(),
+ ParamAttrs(ReadOnlyPtrAttrs, AttributeSet(), ArgPtrAttrs,
+ ArgPtrAttrs, ArgPtrAttrs, ArgPtrAttrs))
+__OMP_RTL_ATTRS(__kmpc_dispatch_fini_4, InaccessibleArgOnlyAttrs,
+ AttributeSet(), ParamAttrs(ReadOnlyPtrAttrs))
+__OMP_RTL_ATTRS(__kmpc_dispatch_fini_4u, InaccessibleArgOnlyAttrs,
+ AttributeSet(), ParamAttrs(ReadOnlyPtrAttrs))
+__OMP_RTL_ATTRS(__kmpc_dispatch_fini_8, InaccessibleArgOnlyAttrs,
+ AttributeSet(), ParamAttrs(ReadOnlyPtrAttrs))
+__OMP_RTL_ATTRS(__kmpc_dispatch_fini_8u, InaccessibleArgOnlyAttrs,
+ AttributeSet(), ParamAttrs(ReadOnlyPtrAttrs))
+__OMP_RTL_ATTRS(__kmpc_team_static_init_4, GetterArgWriteAttrs, AttributeSet(),
+ ParamAttrs(ReadOnlyPtrAttrs, AttributeSet(), ArgPtrAttrs,
+ ArgPtrAttrs, ArgPtrAttrs, ArgPtrAttrs))
+__OMP_RTL_ATTRS(__kmpc_team_static_init_4u, GetterArgWriteAttrs, AttributeSet(),
+ ParamAttrs(ReadOnlyPtrAttrs, AttributeSet(), ArgPtrAttrs,
+ ArgPtrAttrs, ArgPtrAttrs, ArgPtrAttrs))
+__OMP_RTL_ATTRS(__kmpc_team_static_init_8, GetterArgWriteAttrs, AttributeSet(),
+ ParamAttrs(ReadOnlyPtrAttrs, AttributeSet(), ArgPtrAttrs,
+ ArgPtrAttrs, ArgPtrAttrs, ArgPtrAttrs))
+__OMP_RTL_ATTRS(__kmpc_team_static_init_8u, GetterArgWriteAttrs, AttributeSet(),
+ ParamAttrs(ReadOnlyPtrAttrs, AttributeSet(), ArgPtrAttrs,
+ ArgPtrAttrs, ArgPtrAttrs, ArgPtrAttrs))
+__OMP_RTL_ATTRS(__kmpc_dist_for_static_init_4, GetterArgWriteAttrs,
+ AttributeSet(),
+ ParamAttrs(ReadOnlyPtrAttrs, AttributeSet(), AttributeSet(),
+ ArgPtrAttrs, ArgPtrAttrs, ArgPtrAttrs, ArgPtrAttrs,
+ ArgPtrAttrs))
+__OMP_RTL_ATTRS(__kmpc_dist_for_static_init_4u, GetterArgWriteAttrs,
+ AttributeSet(),
+ ParamAttrs(ReadOnlyPtrAttrs, AttributeSet(), AttributeSet(),
+ ArgPtrAttrs, ArgPtrAttrs, ArgPtrAttrs, ArgPtrAttrs,
+ ArgPtrAttrs))
+__OMP_RTL_ATTRS(__kmpc_dist_for_static_init_8, GetterArgWriteAttrs,
+ AttributeSet(),
+ ParamAttrs(ReadOnlyPtrAttrs, AttributeSet(), AttributeSet(),
+ ArgPtrAttrs, ArgPtrAttrs, ArgPtrAttrs, ArgPtrAttrs,
+ ArgPtrAttrs))
+__OMP_RTL_ATTRS(__kmpc_dist_for_static_init_8u, GetterArgWriteAttrs,
+ AttributeSet(),
+ ParamAttrs(ReadOnlyPtrAttrs, AttributeSet(), AttributeSet(),
+ ArgPtrAttrs, ArgPtrAttrs, ArgPtrAttrs, ArgPtrAttrs,
+ ArgPtrAttrs))
+
+__OMP_RTL_ATTRS(__kmpc_single, BarrierAttrs, AttributeSet(),
+ ParamAttrs(ReadOnlyPtrAttrs))
+__OMP_RTL_ATTRS(__kmpc_end_single, BarrierAttrs, AttributeSet(),
+ ParamAttrs(ReadOnlyPtrAttrs))
+
+__OMP_RTL_ATTRS(__kmpc_omp_task_alloc, DefaultAttrs, ReturnPtrAttrs,
+ ParamAttrs(ReadOnlyPtrAttrs, AttributeSet(), AttributeSet(),
+ AttributeSet(), AttributeSet(), ReadOnlyPtrAttrs))
+__OMP_RTL_ATTRS(__kmpc_omp_task, DefaultAttrs, AttributeSet(),
+ ParamAttrs(ReadOnlyPtrAttrs, AttributeSet(), AttributeSet()))
+__OMP_RTL_ATTRS(__kmpc_end_taskgroup, BarrierAttrs, AttributeSet(),
+ ParamAttrs(ReadOnlyPtrAttrs))
+__OMP_RTL_ATTRS(__kmpc_taskgroup, BarrierAttrs, AttributeSet(),
+ ParamAttrs(ReadOnlyPtrAttrs))
+__OMP_RTL_ATTRS(__kmpc_omp_task_begin_if0, DefaultAttrs, AttributeSet(),
+ ParamAttrs(ReadOnlyPtrAttrs))
+__OMP_RTL_ATTRS(__kmpc_omp_task_complete_if0, DefaultAttrs, AttributeSet(),
+ ParamAttrs(ReadOnlyPtrAttrs))
+__OMP_RTL_ATTRS(__kmpc_omp_task_with_deps, DefaultAttrs, AttributeSet(),
+ ParamAttrs(ReadOnlyPtrAttrs, AttributeSet(), AttributeSet(),
+ AttributeSet(), ReadOnlyPtrAttrs, AttributeSet(),
+ ReadOnlyPtrAttrs))
+__OMP_RTL_ATTRS(__kmpc_taskloop, DefaultAttrs, AttributeSet(),
+ ParamAttrs(ReadOnlyPtrAttrs, AttributeSet(), AttributeSet(),
+ AttributeSet(), ArgPtrAttrs, ArgPtrAttrs,
+ AttributeSet(), AttributeSet(), AttributeSet(),
+ AttributeSet(), AttributeSet()))
+__OMP_RTL_ATTRS(__kmpc_omp_target_task_alloc, DefaultAttrs, ReturnPtrAttrs,
+ ParamAttrs(ReadOnlyPtrAttrs, AttributeSet(), AttributeSet(),
+ AttributeSet(), AttributeSet(), ReadOnlyPtrAttrs,
+ AttributeSet()))
+__OMP_RTL_ATTRS(__kmpc_taskred_modifier_init, DefaultAttrs, ReturnPtrAttrs,
+ ParamAttrs(ReadOnlyPtrAttrs))
+__OMP_RTL_ATTRS(__kmpc_taskred_init, DefaultAttrs, AttributeSet(), ParamAttrs())
+__OMP_RTL_ATTRS(__kmpc_task_reduction_modifier_fini, BarrierAttrs,
+ AttributeSet(), ParamAttrs(ReadOnlyPtrAttrs))
+__OMP_RTL_ATTRS(__kmpc_task_reduction_get_th_data, DefaultAttrs, ReturnPtrAttrs,
+ ParamAttrs())
+__OMP_RTL_ATTRS(__kmpc_task_reduction_init, DefaultAttrs, ReturnPtrAttrs,
+ ParamAttrs())
+__OMP_RTL_ATTRS(__kmpc_task_reduction_modifier_init, DefaultAttrs,
+ ReturnPtrAttrs, ParamAttrs())
+__OMP_RTL_ATTRS(__kmpc_proxy_task_completed_ooo, DefaultAttrs, AttributeSet(),
+ ParamAttrs())
+
+__OMP_RTL_ATTRS(__kmpc_omp_wait_deps, BarrierAttrs, AttributeSet(),
+ ParamAttrs(ReadOnlyPtrAttrs, AttributeSet(), AttributeSet(),
+ ReadOnlyPtrAttrs))
+__OMP_RTL_ATTRS(__kmpc_cancellationpoint, DefaultAttrs, AttributeSet(),
+ ParamAttrs(ReadOnlyPtrAttrs))
+
+__OMP_RTL_ATTRS(__kmpc_fork_teams, ForkAttrs, AttributeSet(),
+ ParamAttrs(ReadOnlyPtrAttrs, AttributeSet(), ReadOnlyPtrAttrs))
+__OMP_RTL_ATTRS(__kmpc_push_num_teams, InaccessibleArgOnlyAttrs, AttributeSet(),
+ ParamAttrs(ReadOnlyPtrAttrs))
+
+__OMP_RTL_ATTRS(__kmpc_copyprivate, DefaultAttrs, AttributeSet(),
+ ParamAttrs(ReadOnlyPtrAttrs, AttributeSet(), AttributeSet(),
+ ReadOnlyPtrAttrs))
+__OMP_RTL_ATTRS(__kmpc_threadprivate_cached, DefaultAttrs, ReturnPtrAttrs,
+ ParamAttrs(ReadOnlyPtrAttrs))
+__OMP_RTL_ATTRS(__kmpc_threadprivate_register, DefaultAttrs, AttributeSet(),
+ ParamAttrs(ReadOnlyPtrAttrs, AttributeSet(), ReadOnlyPtrAttrs,
+ ReadOnlyPtrAttrs, ReadOnlyPtrAttrs))
+
+__OMP_RTL_ATTRS(__kmpc_doacross_init, BarrierAttrs, AttributeSet(),
+ ParamAttrs(ReadOnlyPtrAttrs))
+__OMP_RTL_ATTRS(__kmpc_doacross_post, BarrierAttrs, AttributeSet(),
+ ParamAttrs(ReadOnlyPtrAttrs, AttributeSet(), ReadOnlyPtrAttrs))
+__OMP_RTL_ATTRS(__kmpc_doacross_wait, BarrierAttrs, AttributeSet(),
+ ParamAttrs(ReadOnlyPtrAttrs, AttributeSet(), ReadOnlyPtrAttrs))
+__OMP_RTL_ATTRS(__kmpc_doacross_fini, BarrierAttrs, AttributeSet(),
+ ParamAttrs(ReadOnlyPtrAttrs))
+
+__OMP_RTL_ATTRS(__kmpc_alloc, DefaultAttrs, ReturnPtrAttrs, {})
+__OMP_RTL_ATTRS(__kmpc_free, AllocAttrs, AttributeSet(), {})
+
+__OMP_RTL_ATTRS(__kmpc_init_allocator, DefaultAttrs, ReturnPtrAttrs, {})
+__OMP_RTL_ATTRS(__kmpc_destroy_allocator, AllocAttrs, AttributeSet(), {})
+
+__OMP_RTL_ATTRS(__kmpc_push_target_tripcount, SetterAttrs, AttributeSet(), {})
+__OMP_RTL_ATTRS(__tgt_target_mapper, ForkAttrs, AttributeSet(), {})
+__OMP_RTL_ATTRS(__tgt_target_nowait_mapper, ForkAttrs, AttributeSet(), {})
+__OMP_RTL_ATTRS(__tgt_target_teams_mapper, ForkAttrs, AttributeSet(), {})
+__OMP_RTL_ATTRS(__tgt_target_teams_nowait_mapper, ForkAttrs, AttributeSet(), {})
+__OMP_RTL_ATTRS(__tgt_register_requires, ForkAttrs, AttributeSet(), {})
+__OMP_RTL_ATTRS(__tgt_target_data_begin_mapper, ForkAttrs, AttributeSet(), {})
+__OMP_RTL_ATTRS(__tgt_target_data_begin_nowait_mapper, ForkAttrs,
+ AttributeSet(), {})
+__OMP_RTL_ATTRS(__tgt_target_data_end_mapper, ForkAttrs, AttributeSet(), {})
+__OMP_RTL_ATTRS(__tgt_target_data_end_nowait_mapper, ForkAttrs,
+ AttributeSet(), {})
+__OMP_RTL_ATTRS(__tgt_target_data_update_mapper, ForkAttrs, AttributeSet(), {})
+__OMP_RTL_ATTRS(__tgt_target_data_update_nowait_mapper, ForkAttrs,
+ AttributeSet(), {})
+__OMP_RTL_ATTRS(__tgt_mapper_num_components, ForkAttrs, AttributeSet(), {})
+__OMP_RTL_ATTRS(__tgt_push_mapper_component, ForkAttrs, AttributeSet(), {})
+__OMP_RTL_ATTRS(__kmpc_task_allow_completion_event, DefaultAttrs,
+ ReturnPtrAttrs, ParamAttrs(ReadOnlyPtrAttrs))
+
+#undef __OMP_RTL_ATTRS
+#undef OMP_RTL_ATTRS
+#undef AttributeSet
+#undef EnumAttr
+#undef EnumAttrInt
+#undef ParamAttrs
+
+///}
+
+/// KMP ident_t bit flags
+///
+/// In accordance with the values in `openmp/runtime/src/kmp.h`.
+///
+///{
+
+#ifndef OMP_IDENT_FLAG
+#define OMP_IDENT_FLAG(Enum, Str, Value)
+#endif
+
+#define __OMP_IDENT_FLAG(Name, Value) \
+ OMP_IDENT_FLAG(OMP_IDENT_FLAG_##Name, #Name, Value)
+
+__OMP_IDENT_FLAG(KMPC, 0x02)
+__OMP_IDENT_FLAG(BARRIER_EXPL, 0x20)
+__OMP_IDENT_FLAG(BARRIER_IMPL, 0x0040)
+__OMP_IDENT_FLAG(BARRIER_IMPL_MASK, 0x01C0)
+__OMP_IDENT_FLAG(BARRIER_IMPL_FOR, 0x0040)
+__OMP_IDENT_FLAG(BARRIER_IMPL_SECTIONS, 0x00C0)
+__OMP_IDENT_FLAG(BARRIER_IMPL_SINGLE, 0x0140)
+__OMP_IDENT_FLAG(BARRIER_IMPL_WORKSHARE, 0x01C0)
+
+#undef __OMP_IDENT_FLAG
+#undef OMP_IDENT_FLAG
+
+///}
+
+/// KMP cancel kind
+///
+///{
+
+#ifndef OMP_CANCEL_KIND
+#define OMP_CANCEL_KIND(Enum, Str, DirectiveEnum, Value)
+#endif
+
+#define __OMP_CANCEL_KIND(Name, Value) \
+ OMP_CANCEL_KIND(OMP_CANCEL_KIND_##Name, #Name, OMPD_##Name, Value)
+
+__OMP_CANCEL_KIND(parallel, 1)
+__OMP_CANCEL_KIND(for, 2)
+__OMP_CANCEL_KIND(sections, 3)
+__OMP_CANCEL_KIND(taskgroup, 4)
+
+#undef __OMP_CANCEL_KIND
+#undef OMP_CANCEL_KIND
+
+///}
+
+/// Default kinds
+///
+///{
+
+#ifndef OMP_DEFAULT_KIND
+#define OMP_DEFAULT_KIND(Enum, Str)
+#endif
+
+#define __OMP_DEFAULT_KIND(Name) OMP_DEFAULT_KIND(OMP_DEFAULT_##Name, #Name)
+
+__OMP_DEFAULT_KIND(none)
+__OMP_DEFAULT_KIND(shared)
+__OMP_DEFAULT_KIND(firstprivate)
+__OMP_DEFAULT_KIND(unknown)
+
+#undef __OMP_DEFAULT_KIND
+#undef OMP_DEFAULT_KIND
+
+///}
+
+/// Proc bind kinds
+///
+///{
+
+#ifndef OMP_PROC_BIND_KIND
+#define OMP_PROC_BIND_KIND(Enum, Str, Value)
+#endif
+
+#define __OMP_PROC_BIND_KIND(Name, Value) \
+ OMP_PROC_BIND_KIND(OMP_PROC_BIND_##Name, #Name, Value)
+
+__OMP_PROC_BIND_KIND(master, 2)
+__OMP_PROC_BIND_KIND(close, 3)
+__OMP_PROC_BIND_KIND(spread, 4)
+__OMP_PROC_BIND_KIND(default, 6)
+__OMP_PROC_BIND_KIND(unknown, 7)
+
+#undef __OMP_PROC_BIND_KIND
+#undef OMP_PROC_BIND_KIND
+
+///}
+
+/// OpenMP context related definitions:
+/// - trait set selector
+/// - trait selector
+/// - trait property
+///
+///{
+
+#ifndef OMP_TRAIT_SET
+#define OMP_TRAIT_SET(Enum, Str)
+#endif
+#ifndef OMP_TRAIT_SELECTOR
+#define OMP_TRAIT_SELECTOR(Enum, TraitSetEnum, Str, RequiresProperty)
+#endif
+#ifndef OMP_TRAIT_PROPERTY
+#define OMP_TRAIT_PROPERTY(Enum, TraitSetEnum, TraitSelectorEnum, Str)
+#endif
+#ifndef OMP_LAST_TRAIT_PROPERTY
+#define OMP_LAST_TRAIT_PROPERTY(Enum)
+#endif
+
+#define __OMP_TRAIT_SET(Name) OMP_TRAIT_SET(Name, #Name)
+#define __OMP_TRAIT_SELECTOR(TraitSet, Name, RequiresProperty) \
+ OMP_TRAIT_SELECTOR(TraitSet##_##Name, TraitSet, #Name, RequiresProperty)
+#define __OMP_TRAIT_SELECTOR_AND_PROPERTY(TraitSet, Name) \
+ OMP_TRAIT_SELECTOR(TraitSet##_##Name, TraitSet, #Name, false) \
+ OMP_TRAIT_PROPERTY(TraitSet##_##Name##_##Name, TraitSet, TraitSet##_##Name, \
+ #Name)
+#define __OMP_TRAIT_PROPERTY(TraitSet, TraitSelector, Name) \
+ OMP_TRAIT_PROPERTY(TraitSet##_##TraitSelector##_##Name, TraitSet, \
+ TraitSet##_##TraitSelector, #Name)
+
+// "invalid" must go first.
+OMP_TRAIT_SET(invalid, "invalid")
+OMP_TRAIT_SELECTOR(invalid, invalid, "invalid", false)
+OMP_TRAIT_PROPERTY(invalid, invalid, invalid, "invalid")
+
+__OMP_TRAIT_SET(construct)
+__OMP_TRAIT_SELECTOR_AND_PROPERTY(construct, target)
+__OMP_TRAIT_SELECTOR_AND_PROPERTY(construct, teams)
+__OMP_TRAIT_SELECTOR_AND_PROPERTY(construct, parallel)
+__OMP_TRAIT_SELECTOR_AND_PROPERTY(construct, for)
+__OMP_TRAIT_SELECTOR_AND_PROPERTY(construct, simd)
+
+__OMP_TRAIT_SET(device)
+
+__OMP_TRAIT_SELECTOR(device, kind, true)
+
+__OMP_TRAIT_PROPERTY(device, kind, host)
+__OMP_TRAIT_PROPERTY(device, kind, nohost)
+__OMP_TRAIT_PROPERTY(device, kind, cpu)
+__OMP_TRAIT_PROPERTY(device, kind, gpu)
+__OMP_TRAIT_PROPERTY(device, kind, fpga)
+__OMP_TRAIT_PROPERTY(device, kind, any)
+
+__OMP_TRAIT_SELECTOR(device, arch, true)
+
+__OMP_TRAIT_PROPERTY(device, arch, arm)
+__OMP_TRAIT_PROPERTY(device, arch, armeb)
+__OMP_TRAIT_PROPERTY(device, arch, aarch64)
+__OMP_TRAIT_PROPERTY(device, arch, aarch64_be)
+__OMP_TRAIT_PROPERTY(device, arch, aarch64_32)
+__OMP_TRAIT_PROPERTY(device, arch, ppc)
+__OMP_TRAIT_PROPERTY(device, arch, ppcle)
+__OMP_TRAIT_PROPERTY(device, arch, ppc64)
+__OMP_TRAIT_PROPERTY(device, arch, ppc64le)
+__OMP_TRAIT_PROPERTY(device, arch, x86)
+__OMP_TRAIT_PROPERTY(device, arch, x86_64)
+__OMP_TRAIT_PROPERTY(device, arch, amdgcn)
+__OMP_TRAIT_PROPERTY(device, arch, nvptx)
+__OMP_TRAIT_PROPERTY(device, arch, nvptx64)
+
+__OMP_TRAIT_SET(implementation)
+
+__OMP_TRAIT_SELECTOR(implementation, vendor, true)
+
+__OMP_TRAIT_PROPERTY(implementation, vendor, amd)
+__OMP_TRAIT_PROPERTY(implementation, vendor, arm)
+__OMP_TRAIT_PROPERTY(implementation, vendor, bsc)
+__OMP_TRAIT_PROPERTY(implementation, vendor, cray)
+__OMP_TRAIT_PROPERTY(implementation, vendor, fujitsu)
+__OMP_TRAIT_PROPERTY(implementation, vendor, gnu)
+__OMP_TRAIT_PROPERTY(implementation, vendor, ibm)
+__OMP_TRAIT_PROPERTY(implementation, vendor, intel)
+__OMP_TRAIT_PROPERTY(implementation, vendor, llvm)
+__OMP_TRAIT_PROPERTY(implementation, vendor, pgi)
+__OMP_TRAIT_PROPERTY(implementation, vendor, ti)
+__OMP_TRAIT_PROPERTY(implementation, vendor, unknown)
+
+__OMP_TRAIT_SELECTOR(implementation, extension, true)
+__OMP_TRAIT_PROPERTY(implementation, extension, match_all)
+__OMP_TRAIT_PROPERTY(implementation, extension, match_any)
+__OMP_TRAIT_PROPERTY(implementation, extension, match_none)
+__OMP_TRAIT_PROPERTY(implementation, extension, disable_implicit_base)
+__OMP_TRAIT_PROPERTY(implementation, extension, allow_templates)
+
+__OMP_TRAIT_SET(user)
+
+__OMP_TRAIT_SELECTOR(user, condition, true)
+
+__OMP_TRAIT_PROPERTY(user, condition, true)
+__OMP_TRAIT_PROPERTY(user, condition, false)
+__OMP_TRAIT_PROPERTY(user, condition, unknown)
+
+
+// Note that we put isa last so that the other conditions are checked first.
+// This allows us to issue warnings wrt. isa only if we match otherwise.
+__OMP_TRAIT_SELECTOR(device, isa, true)
+
+// We use "__ANY" as a placeholder in the isa property to denote the
+// conceptual "any", not the literal `any` used in kind. The string we
+// we use is not important except that it will show up in diagnostics.
+OMP_TRAIT_PROPERTY(device_isa___ANY, device, device_isa,
+ "<any, entirely target dependent>")
+
+
+#undef OMP_TRAIT_SET
+#undef __OMP_TRAIT_SET
+///}
+
+/// Traits for the requires directive
+///
+/// These will (potentially) become trait selectors for the OpenMP context if
+/// the OMP_REQUIRES_TRAIT macro is not defined.
+///
+///{
+
+#ifdef OMP_REQUIRES_TRAIT
+#define __OMP_REQUIRES_TRAIT(Name) \
+ OMP_REQUIRES_TRAIT(OMP_REQUIRES_TRAIT_##Name, #Name)
+#else
+#define __OMP_REQUIRES_TRAIT(Name) \
+ __OMP_TRAIT_SELECTOR_AND_PROPERTY(implementation, Name)
+#endif
+
+__OMP_REQUIRES_TRAIT(unified_address)
+__OMP_REQUIRES_TRAIT(unified_shared_memory)
+__OMP_REQUIRES_TRAIT(reverse_offload)
+__OMP_REQUIRES_TRAIT(dynamic_allocators)
+__OMP_REQUIRES_TRAIT(atomic_default_mem_order)
+
+OMP_LAST_TRAIT_PROPERTY(
+ implementation_atomic_default_mem_order_atomic_default_mem_order)
+
+#undef __OMP_TRAIT_SELECTOR_AND_PROPERTY
+#undef OMP_TRAIT_SELECTOR
+#undef __OMP_TRAIT_SELECTOR
+#undef OMP_TRAIT_PROPERTY
+#undef OMP_LAST_TRAIT_PROPERTY
+#undef __OMP_TRAIT_PROPERTY
+#undef __OMP_REQUIRES_TRAIT
+#undef OMP_REQUIRES_TRAIT
+///}
+
+
+/// Assumption clauses
+///
+///{
+
+#ifdef OMP_ASSUME_CLAUSE
+#define __OMP_ASSUME_CLAUSE(Identifier, StartsWith, HasDirectiveList, HasExpression) \
+OMP_ASSUME_CLAUSE(Identifier, StartsWith, HasDirectiveList, HasExpression)
+#else
+#define __OMP_ASSUME_CLAUSE(...)
+#endif
+
+__OMP_ASSUME_CLAUSE(llvm::StringLiteral("ext_"), true, false, false)
+__OMP_ASSUME_CLAUSE(llvm::StringLiteral("absent"), false, true, false)
+__OMP_ASSUME_CLAUSE(llvm::StringLiteral("contains"), false, true, false)
+__OMP_ASSUME_CLAUSE(llvm::StringLiteral("holds"), false, false, true)
+__OMP_ASSUME_CLAUSE(llvm::StringLiteral("no_openmp"), false, false, false)
+__OMP_ASSUME_CLAUSE(llvm::StringLiteral("no_openmp_routines"), false, false, false)
+__OMP_ASSUME_CLAUSE(llvm::StringLiteral("no_parallelism"), false, false, false)
+
+#undef __OMP_ASSUME_CLAUSE
+#undef OMP_ASSUME_CLAUSE
+///}