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/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;
+}