| //===--- OpenMPKinds.def - OpenMP directives and clauses list ---*- C++ -*-===// |
| // |
| // The LLVM Compiler Infrastructure |
| // |
| // This file is distributed under the University of Illinois Open Source |
| // License. See LICENSE.TXT for details. |
| // |
| //===----------------------------------------------------------------------===// |
| /// \file |
| /// This file defines the list of supported OpenMP directives and |
| /// clauses. |
| /// |
| //===----------------------------------------------------------------------===// |
| |
| #ifndef OPENMP_DIRECTIVE |
| # define OPENMP_DIRECTIVE(Name) |
| #endif |
| #ifndef OPENMP_DIRECTIVE_EXT |
| #define OPENMP_DIRECTIVE_EXT(Name, Str) |
| #endif |
| #ifndef OPENMP_CLAUSE |
| # define OPENMP_CLAUSE(Name, Class) |
| #endif |
| #ifndef OPENMP_PARALLEL_CLAUSE |
| # define OPENMP_PARALLEL_CLAUSE(Name) |
| #endif |
| #ifndef OPENMP_SIMD_CLAUSE |
| # define OPENMP_SIMD_CLAUSE(Name) |
| #endif |
| #ifndef OPENMP_FOR_CLAUSE |
| # define OPENMP_FOR_CLAUSE(Name) |
| #endif |
| #ifndef OPENMP_FOR_SIMD_CLAUSE |
| # define OPENMP_FOR_SIMD_CLAUSE(Name) |
| #endif |
| #ifndef OPENMP_SECTIONS_CLAUSE |
| # define OPENMP_SECTIONS_CLAUSE(Name) |
| #endif |
| #ifndef OPENMP_SINGLE_CLAUSE |
| # define OPENMP_SINGLE_CLAUSE(Name) |
| #endif |
| #ifndef OPENMP_PARALLEL_FOR_CLAUSE |
| # define OPENMP_PARALLEL_FOR_CLAUSE(Name) |
| #endif |
| #ifndef OPENMP_PARALLEL_FOR_SIMD_CLAUSE |
| # define OPENMP_PARALLEL_FOR_SIMD_CLAUSE(Name) |
| #endif |
| #ifndef OPENMP_PARALLEL_SECTIONS_CLAUSE |
| # define OPENMP_PARALLEL_SECTIONS_CLAUSE(Name) |
| #endif |
| #ifndef OPENMP_TASK_CLAUSE |
| # define OPENMP_TASK_CLAUSE(Name) |
| #endif |
| #ifndef OPENMP_ATOMIC_CLAUSE |
| # define OPENMP_ATOMIC_CLAUSE(Name) |
| #endif |
| #ifndef OPENMP_TARGET_CLAUSE |
| # define OPENMP_TARGET_CLAUSE(Name) |
| #endif |
| #ifndef OPENMP_TARGET_DATA_CLAUSE |
| # define OPENMP_TARGET_DATA_CLAUSE(Name) |
| #endif |
| #ifndef OPENMP_TARGET_ENTER_DATA_CLAUSE |
| #define OPENMP_TARGET_ENTER_DATA_CLAUSE(Name) |
| #endif |
| #ifndef OPENMP_TARGET_EXIT_DATA_CLAUSE |
| #define OPENMP_TARGET_EXIT_DATA_CLAUSE(Name) |
| #endif |
| #ifndef OPENMP_TARGET_PARALLEL_CLAUSE |
| # define OPENMP_TARGET_PARALLEL_CLAUSE(Name) |
| #endif |
| #ifndef OPENMP_TARGET_PARALLEL_FOR_CLAUSE |
| # define OPENMP_TARGET_PARALLEL_FOR_CLAUSE(Name) |
| #endif |
| #ifndef OPENMP_TARGET_UPDATE_CLAUSE |
| # define OPENMP_TARGET_UPDATE_CLAUSE(Name) |
| #endif |
| #ifndef OPENMP_TEAMS_CLAUSE |
| # define OPENMP_TEAMS_CLAUSE(Name) |
| #endif |
| #ifndef OPENMP_CANCEL_CLAUSE |
| # define OPENMP_CANCEL_CLAUSE(Name) |
| #endif |
| #ifndef OPENMP_ORDERED_CLAUSE |
| # define OPENMP_ORDERED_CLAUSE(Name) |
| #endif |
| #ifndef OPENMP_TASKLOOP_CLAUSE |
| # define OPENMP_TASKLOOP_CLAUSE(Name) |
| #endif |
| #ifndef OPENMP_TASKLOOP_SIMD_CLAUSE |
| # define OPENMP_TASKLOOP_SIMD_CLAUSE(Name) |
| #endif |
| #ifndef OPENMP_CRITICAL_CLAUSE |
| # define OPENMP_CRITICAL_CLAUSE(Name) |
| #endif |
| #ifndef OPENMP_DISTRIBUTE_CLAUSE |
| #define OPENMP_DISTRIBUTE_CLAUSE(Name) |
| #endif |
| #ifndef OPENMP_DEFAULT_KIND |
| # define OPENMP_DEFAULT_KIND(Name) |
| #endif |
| #ifndef OPENMP_PROC_BIND_KIND |
| # define OPENMP_PROC_BIND_KIND(Name) |
| #endif |
| #ifndef OPENMP_SCHEDULE_KIND |
| #define OPENMP_SCHEDULE_KIND(Name) |
| #endif |
| #ifndef OPENMP_SCHEDULE_MODIFIER |
| #define OPENMP_SCHEDULE_MODIFIER(Name) |
| #endif |
| #ifndef OPENMP_DEPEND_KIND |
| #define OPENMP_DEPEND_KIND(Name) |
| #endif |
| #ifndef OPENMP_LINEAR_KIND |
| #define OPENMP_LINEAR_KIND(Name) |
| #endif |
| #ifndef OPENMP_MAP_KIND |
| #define OPENMP_MAP_KIND(Name) |
| #endif |
| #ifndef OPENMP_DIST_SCHEDULE_KIND |
| #define OPENMP_DIST_SCHEDULE_KIND(Name) |
| #endif |
| #ifndef OPENMP_DEFAULTMAP_KIND |
| #define OPENMP_DEFAULTMAP_KIND(Name) |
| #endif |
| #ifndef OPENMP_DEFAULTMAP_MODIFIER |
| #define OPENMP_DEFAULTMAP_MODIFIER(Name) |
| #endif |
| #ifndef OPENMP_DISTRIBUTE_PARALLEL_FOR_CLAUSE |
| #define OPENMP_DISTRIBUTE_PARALLEL_FOR_CLAUSE(Name) |
| #endif |
| #ifndef OPENMP_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE |
| #define OPENMP_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(Name) |
| #endif |
| #ifndef OPENMP_DISTRIBUTE_SIMD_CLAUSE |
| #define OPENMP_DISTRIBUTE_SIMD_CLAUSE(Name) |
| #endif |
| #ifndef OPENMP_TARGET_PARALLEL_FOR_SIMD_CLAUSE |
| #define OPENMP_TARGET_PARALLEL_FOR_SIMD_CLAUSE(Name) |
| #endif |
| #ifndef OPENMP_TARGET_SIMD_CLAUSE |
| #define OPENMP_TARGET_SIMD_CLAUSE(Name) |
| #endif |
| #ifndef OPENMP_TEAMS_DISTRIBUTE_CLAUSE |
| #define OPENMP_TEAMS_DISTRIBUTE_CLAUSE(Name) |
| #endif |
| #ifndef OPENMP_TEAMS_DISTRIBUTE_SIMD_CLAUSE |
| #define OPENMP_TEAMS_DISTRIBUTE_SIMD_CLAUSE(Name) |
| #endif |
| #ifndef OPENMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE |
| #define OPENMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(Name) |
| #endif |
| #ifndef OPENMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_CLAUSE |
| #define OPENMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_CLAUSE(Name) |
| #endif |
| #ifndef OPENMP_TARGET_TEAMS_CLAUSE |
| #define OPENMP_TARGET_TEAMS_CLAUSE(Name) |
| #endif |
| #ifndef OPENMP_TARGET_TEAMS_DISTRIBUTE_CLAUSE |
| #define OPENMP_TARGET_TEAMS_DISTRIBUTE_CLAUSE(Name) |
| #endif |
| #ifndef OPENMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_CLAUSE |
| #define OPENMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_CLAUSE(Name) |
| #endif |
| #ifndef OPENMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE |
| #define OPENMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(Name) |
| #endif |
| #ifndef OPENMP_TARGET_TEAMS_DISTRIBUTE_SIMD_CLAUSE |
| #define OPENMP_TARGET_TEAMS_DISTRIBUTE_SIMD_CLAUSE(Name) |
| #endif |
| #ifndef OPENMP_TASKGROUP_CLAUSE |
| #define OPENMP_TASKGROUP_CLAUSE(Name) |
| #endif |
| |
| // OpenMP directives. |
| OPENMP_DIRECTIVE(threadprivate) |
| OPENMP_DIRECTIVE(parallel) |
| OPENMP_DIRECTIVE(task) |
| OPENMP_DIRECTIVE(simd) |
| OPENMP_DIRECTIVE(for) |
| OPENMP_DIRECTIVE(sections) |
| OPENMP_DIRECTIVE(section) |
| OPENMP_DIRECTIVE(single) |
| OPENMP_DIRECTIVE(master) |
| OPENMP_DIRECTIVE(critical) |
| OPENMP_DIRECTIVE(taskyield) |
| OPENMP_DIRECTIVE(barrier) |
| OPENMP_DIRECTIVE(taskwait) |
| OPENMP_DIRECTIVE(taskgroup) |
| OPENMP_DIRECTIVE(flush) |
| OPENMP_DIRECTIVE(ordered) |
| OPENMP_DIRECTIVE(atomic) |
| OPENMP_DIRECTIVE(target) |
| OPENMP_DIRECTIVE(teams) |
| OPENMP_DIRECTIVE(cancel) |
| OPENMP_DIRECTIVE_EXT(target_data, "target data") |
| OPENMP_DIRECTIVE_EXT(target_enter_data, "target enter data") |
| OPENMP_DIRECTIVE_EXT(target_exit_data, "target exit data") |
| OPENMP_DIRECTIVE_EXT(target_parallel, "target parallel") |
| OPENMP_DIRECTIVE_EXT(target_parallel_for, "target parallel for") |
| OPENMP_DIRECTIVE_EXT(target_update, "target update") |
| OPENMP_DIRECTIVE_EXT(parallel_for, "parallel for") |
| OPENMP_DIRECTIVE_EXT(parallel_for_simd, "parallel for simd") |
| OPENMP_DIRECTIVE_EXT(parallel_sections, "parallel sections") |
| OPENMP_DIRECTIVE_EXT(for_simd, "for simd") |
| OPENMP_DIRECTIVE_EXT(cancellation_point, "cancellation point") |
| OPENMP_DIRECTIVE_EXT(declare_reduction, "declare reduction") |
| OPENMP_DIRECTIVE_EXT(declare_simd, "declare simd") |
| OPENMP_DIRECTIVE(taskloop) |
| OPENMP_DIRECTIVE_EXT(taskloop_simd, "taskloop simd") |
| OPENMP_DIRECTIVE(distribute) |
| OPENMP_DIRECTIVE_EXT(declare_target, "declare target") |
| OPENMP_DIRECTIVE_EXT(end_declare_target, "end declare target") |
| OPENMP_DIRECTIVE_EXT(distribute_parallel_for, "distribute parallel for") |
| OPENMP_DIRECTIVE_EXT(distribute_parallel_for_simd, "distribute parallel for simd") |
| OPENMP_DIRECTIVE_EXT(distribute_simd, "distribute simd") |
| OPENMP_DIRECTIVE_EXT(target_parallel_for_simd, "target parallel for simd") |
| OPENMP_DIRECTIVE_EXT(target_simd, "target simd") |
| OPENMP_DIRECTIVE_EXT(teams_distribute, "teams distribute") |
| OPENMP_DIRECTIVE_EXT(teams_distribute_simd, "teams distribute simd") |
| OPENMP_DIRECTIVE_EXT(teams_distribute_parallel_for_simd, "teams distribute parallel for simd") |
| OPENMP_DIRECTIVE_EXT(teams_distribute_parallel_for, "teams distribute parallel for") |
| OPENMP_DIRECTIVE_EXT(target_teams, "target teams") |
| OPENMP_DIRECTIVE_EXT(target_teams_distribute, "target teams distribute") |
| OPENMP_DIRECTIVE_EXT(target_teams_distribute_parallel_for, "target teams distribute parallel for") |
| OPENMP_DIRECTIVE_EXT(target_teams_distribute_parallel_for_simd, "target teams distribute parallel for simd") |
| OPENMP_DIRECTIVE_EXT(target_teams_distribute_simd, "target teams distribute simd") |
| |
| // OpenMP clauses. |
| OPENMP_CLAUSE(if, OMPIfClause) |
| OPENMP_CLAUSE(final, OMPFinalClause) |
| OPENMP_CLAUSE(num_threads, OMPNumThreadsClause) |
| OPENMP_CLAUSE(safelen, OMPSafelenClause) |
| OPENMP_CLAUSE(simdlen, OMPSimdlenClause) |
| OPENMP_CLAUSE(collapse, OMPCollapseClause) |
| OPENMP_CLAUSE(default, OMPDefaultClause) |
| OPENMP_CLAUSE(private, OMPPrivateClause) |
| OPENMP_CLAUSE(firstprivate, OMPFirstprivateClause) |
| OPENMP_CLAUSE(lastprivate, OMPLastprivateClause) |
| OPENMP_CLAUSE(shared, OMPSharedClause) |
| OPENMP_CLAUSE(reduction, OMPReductionClause) |
| OPENMP_CLAUSE(linear, OMPLinearClause) |
| OPENMP_CLAUSE(aligned, OMPAlignedClause) |
| OPENMP_CLAUSE(copyin, OMPCopyinClause) |
| OPENMP_CLAUSE(copyprivate, OMPCopyprivateClause) |
| OPENMP_CLAUSE(proc_bind, OMPProcBindClause) |
| OPENMP_CLAUSE(schedule, OMPScheduleClause) |
| OPENMP_CLAUSE(ordered, OMPOrderedClause) |
| OPENMP_CLAUSE(nowait, OMPNowaitClause) |
| OPENMP_CLAUSE(untied, OMPUntiedClause) |
| OPENMP_CLAUSE(mergeable, OMPMergeableClause) |
| OPENMP_CLAUSE(flush, OMPFlushClause) |
| OPENMP_CLAUSE(read, OMPReadClause) |
| OPENMP_CLAUSE(write, OMPWriteClause) |
| OPENMP_CLAUSE(update, OMPUpdateClause) |
| OPENMP_CLAUSE(capture, OMPCaptureClause) |
| OPENMP_CLAUSE(seq_cst, OMPSeqCstClause) |
| OPENMP_CLAUSE(depend, OMPDependClause) |
| OPENMP_CLAUSE(device, OMPDeviceClause) |
| OPENMP_CLAUSE(threads, OMPThreadsClause) |
| OPENMP_CLAUSE(simd, OMPSIMDClause) |
| OPENMP_CLAUSE(map, OMPMapClause) |
| OPENMP_CLAUSE(num_teams, OMPNumTeamsClause) |
| OPENMP_CLAUSE(thread_limit, OMPThreadLimitClause) |
| OPENMP_CLAUSE(priority, OMPPriorityClause) |
| OPENMP_CLAUSE(grainsize, OMPGrainsizeClause) |
| OPENMP_CLAUSE(nogroup, OMPNogroupClause) |
| OPENMP_CLAUSE(num_tasks, OMPNumTasksClause) |
| OPENMP_CLAUSE(hint, OMPHintClause) |
| OPENMP_CLAUSE(dist_schedule, OMPDistScheduleClause) |
| OPENMP_CLAUSE(defaultmap, OMPDefaultmapClause) |
| OPENMP_CLAUSE(to, OMPToClause) |
| OPENMP_CLAUSE(from, OMPFromClause) |
| OPENMP_CLAUSE(use_device_ptr, OMPUseDevicePtrClause) |
| OPENMP_CLAUSE(is_device_ptr, OMPIsDevicePtrClause) |
| OPENMP_CLAUSE(task_reduction, OMPTaskReductionClause) |
| OPENMP_CLAUSE(in_reduction, OMPInReductionClause) |
| |
| // Clauses allowed for OpenMP directive 'parallel'. |
| OPENMP_PARALLEL_CLAUSE(if) |
| OPENMP_PARALLEL_CLAUSE(num_threads) |
| OPENMP_PARALLEL_CLAUSE(default) |
| OPENMP_PARALLEL_CLAUSE(proc_bind) |
| OPENMP_PARALLEL_CLAUSE(private) |
| OPENMP_PARALLEL_CLAUSE(firstprivate) |
| OPENMP_PARALLEL_CLAUSE(shared) |
| OPENMP_PARALLEL_CLAUSE(reduction) |
| OPENMP_PARALLEL_CLAUSE(copyin) |
| |
| // Clauses allowed for directive 'omp simd'. |
| OPENMP_SIMD_CLAUSE(private) |
| OPENMP_SIMD_CLAUSE(lastprivate) |
| OPENMP_SIMD_CLAUSE(linear) |
| OPENMP_SIMD_CLAUSE(aligned) |
| OPENMP_SIMD_CLAUSE(safelen) |
| OPENMP_SIMD_CLAUSE(simdlen) |
| OPENMP_SIMD_CLAUSE(collapse) |
| OPENMP_SIMD_CLAUSE(reduction) |
| |
| // Clauses allowed for directive 'omp for'. |
| OPENMP_FOR_CLAUSE(private) |
| OPENMP_FOR_CLAUSE(lastprivate) |
| OPENMP_FOR_CLAUSE(firstprivate) |
| OPENMP_FOR_CLAUSE(reduction) |
| OPENMP_FOR_CLAUSE(collapse) |
| OPENMP_FOR_CLAUSE(schedule) |
| OPENMP_FOR_CLAUSE(ordered) |
| OPENMP_FOR_CLAUSE(nowait) |
| OPENMP_FOR_CLAUSE(linear) |
| |
| // Clauses allowed for directive 'omp for simd'. |
| OPENMP_FOR_SIMD_CLAUSE(private) |
| OPENMP_FOR_SIMD_CLAUSE(firstprivate) |
| OPENMP_FOR_SIMD_CLAUSE(lastprivate) |
| OPENMP_FOR_SIMD_CLAUSE(reduction) |
| OPENMP_FOR_SIMD_CLAUSE(schedule) |
| OPENMP_FOR_SIMD_CLAUSE(collapse) |
| OPENMP_FOR_SIMD_CLAUSE(nowait) |
| OPENMP_FOR_SIMD_CLAUSE(safelen) |
| OPENMP_FOR_SIMD_CLAUSE(simdlen) |
| OPENMP_FOR_SIMD_CLAUSE(linear) |
| OPENMP_FOR_SIMD_CLAUSE(aligned) |
| OPENMP_FOR_SIMD_CLAUSE(ordered) |
| |
| // Clauses allowed for OpenMP directive 'omp sections'. |
| OPENMP_SECTIONS_CLAUSE(private) |
| OPENMP_SECTIONS_CLAUSE(lastprivate) |
| OPENMP_SECTIONS_CLAUSE(firstprivate) |
| OPENMP_SECTIONS_CLAUSE(reduction) |
| OPENMP_SECTIONS_CLAUSE(nowait) |
| |
| // Clauses allowed for directive 'omp single'. |
| OPENMP_SINGLE_CLAUSE(private) |
| OPENMP_SINGLE_CLAUSE(firstprivate) |
| OPENMP_SINGLE_CLAUSE(copyprivate) |
| OPENMP_SINGLE_CLAUSE(nowait) |
| |
| // Clauses allowed for OpenMP directive 'cancel'. |
| OPENMP_CANCEL_CLAUSE(if) |
| |
| // Static attributes for 'default' clause. |
| OPENMP_DEFAULT_KIND(none) |
| OPENMP_DEFAULT_KIND(shared) |
| |
| // Static attributes for 'proc_bind' clause. |
| OPENMP_PROC_BIND_KIND(master) |
| OPENMP_PROC_BIND_KIND(close) |
| OPENMP_PROC_BIND_KIND(spread) |
| |
| // Static attributes for 'schedule' clause. |
| OPENMP_SCHEDULE_KIND(static) |
| OPENMP_SCHEDULE_KIND(dynamic) |
| OPENMP_SCHEDULE_KIND(guided) |
| OPENMP_SCHEDULE_KIND(auto) |
| OPENMP_SCHEDULE_KIND(runtime) |
| |
| // Modifiers for 'schedule' clause. |
| OPENMP_SCHEDULE_MODIFIER(monotonic) |
| OPENMP_SCHEDULE_MODIFIER(nonmonotonic) |
| OPENMP_SCHEDULE_MODIFIER(simd) |
| |
| // Static attributes for 'defaultmap' clause. |
| OPENMP_DEFAULTMAP_KIND(scalar) |
| |
| // Modifiers for 'defaultmap' clause. |
| OPENMP_DEFAULTMAP_MODIFIER(tofrom) |
| |
| // Static attributes for 'depend' clause. |
| OPENMP_DEPEND_KIND(in) |
| OPENMP_DEPEND_KIND(out) |
| OPENMP_DEPEND_KIND(inout) |
| OPENMP_DEPEND_KIND(source) |
| OPENMP_DEPEND_KIND(sink) |
| |
| // Modifiers for 'linear' clause. |
| OPENMP_LINEAR_KIND(val) |
| OPENMP_LINEAR_KIND(ref) |
| OPENMP_LINEAR_KIND(uval) |
| |
| // Clauses allowed for OpenMP directive 'parallel for'. |
| OPENMP_PARALLEL_FOR_CLAUSE(if) |
| OPENMP_PARALLEL_FOR_CLAUSE(num_threads) |
| OPENMP_PARALLEL_FOR_CLAUSE(default) |
| OPENMP_PARALLEL_FOR_CLAUSE(proc_bind) |
| OPENMP_PARALLEL_FOR_CLAUSE(private) |
| OPENMP_PARALLEL_FOR_CLAUSE(firstprivate) |
| OPENMP_PARALLEL_FOR_CLAUSE(shared) |
| OPENMP_PARALLEL_FOR_CLAUSE(reduction) |
| OPENMP_PARALLEL_FOR_CLAUSE(copyin) |
| OPENMP_PARALLEL_FOR_CLAUSE(lastprivate) |
| OPENMP_PARALLEL_FOR_CLAUSE(collapse) |
| OPENMP_PARALLEL_FOR_CLAUSE(schedule) |
| OPENMP_PARALLEL_FOR_CLAUSE(ordered) |
| OPENMP_PARALLEL_FOR_CLAUSE(linear) |
| |
| // Clauses allowed for OpenMP directive 'parallel for simd'. |
| OPENMP_PARALLEL_FOR_SIMD_CLAUSE(if) |
| OPENMP_PARALLEL_FOR_SIMD_CLAUSE(num_threads) |
| OPENMP_PARALLEL_FOR_SIMD_CLAUSE(default) |
| OPENMP_PARALLEL_FOR_SIMD_CLAUSE(proc_bind) |
| OPENMP_PARALLEL_FOR_SIMD_CLAUSE(private) |
| OPENMP_PARALLEL_FOR_SIMD_CLAUSE(firstprivate) |
| OPENMP_PARALLEL_FOR_SIMD_CLAUSE(shared) |
| OPENMP_PARALLEL_FOR_SIMD_CLAUSE(reduction) |
| OPENMP_PARALLEL_FOR_SIMD_CLAUSE(copyin) |
| OPENMP_PARALLEL_FOR_SIMD_CLAUSE(lastprivate) |
| OPENMP_PARALLEL_FOR_SIMD_CLAUSE(collapse) |
| OPENMP_PARALLEL_FOR_SIMD_CLAUSE(schedule) |
| OPENMP_PARALLEL_FOR_SIMD_CLAUSE(safelen) |
| OPENMP_PARALLEL_FOR_SIMD_CLAUSE(simdlen) |
| OPENMP_PARALLEL_FOR_SIMD_CLAUSE(linear) |
| OPENMP_PARALLEL_FOR_SIMD_CLAUSE(aligned) |
| OPENMP_PARALLEL_FOR_SIMD_CLAUSE(ordered) |
| |
| // Clauses allowed for OpenMP directive 'parallel sections'. |
| OPENMP_PARALLEL_SECTIONS_CLAUSE(if) |
| OPENMP_PARALLEL_SECTIONS_CLAUSE(num_threads) |
| OPENMP_PARALLEL_SECTIONS_CLAUSE(default) |
| OPENMP_PARALLEL_SECTIONS_CLAUSE(proc_bind) |
| OPENMP_PARALLEL_SECTIONS_CLAUSE(private) |
| OPENMP_PARALLEL_SECTIONS_CLAUSE(firstprivate) |
| OPENMP_PARALLEL_SECTIONS_CLAUSE(shared) |
| OPENMP_PARALLEL_SECTIONS_CLAUSE(reduction) |
| OPENMP_PARALLEL_SECTIONS_CLAUSE(copyin) |
| OPENMP_PARALLEL_SECTIONS_CLAUSE(lastprivate) |
| |
| // Clauses allowed for OpenMP directive 'task'. |
| OPENMP_TASK_CLAUSE(if) |
| OPENMP_TASK_CLAUSE(final) |
| OPENMP_TASK_CLAUSE(default) |
| OPENMP_TASK_CLAUSE(private) |
| OPENMP_TASK_CLAUSE(firstprivate) |
| OPENMP_TASK_CLAUSE(shared) |
| OPENMP_TASK_CLAUSE(untied) |
| OPENMP_TASK_CLAUSE(mergeable) |
| OPENMP_TASK_CLAUSE(depend) |
| OPENMP_TASK_CLAUSE(priority) |
| OPENMP_TASK_CLAUSE(in_reduction) |
| |
| // Clauses allowed for OpenMP directive 'atomic'. |
| OPENMP_ATOMIC_CLAUSE(read) |
| OPENMP_ATOMIC_CLAUSE(write) |
| OPENMP_ATOMIC_CLAUSE(update) |
| OPENMP_ATOMIC_CLAUSE(capture) |
| OPENMP_ATOMIC_CLAUSE(seq_cst) |
| |
| // Clauses allowed for OpenMP directive 'target'. |
| OPENMP_TARGET_CLAUSE(if) |
| OPENMP_TARGET_CLAUSE(device) |
| OPENMP_TARGET_CLAUSE(map) |
| OPENMP_TARGET_CLAUSE(private) |
| OPENMP_TARGET_CLAUSE(nowait) |
| OPENMP_TARGET_CLAUSE(depend) |
| OPENMP_TARGET_CLAUSE(defaultmap) |
| OPENMP_TARGET_CLAUSE(firstprivate) |
| OPENMP_TARGET_CLAUSE(is_device_ptr) |
| OPENMP_TARGET_CLAUSE(reduction) |
| |
| // Clauses allowed for OpenMP directive 'target data'. |
| OPENMP_TARGET_DATA_CLAUSE(if) |
| OPENMP_TARGET_DATA_CLAUSE(device) |
| OPENMP_TARGET_DATA_CLAUSE(map) |
| OPENMP_TARGET_DATA_CLAUSE(use_device_ptr) |
| |
| // Clauses allowed for OpenMP directive 'target enter data'. |
| OPENMP_TARGET_ENTER_DATA_CLAUSE(if) |
| OPENMP_TARGET_ENTER_DATA_CLAUSE(device) |
| OPENMP_TARGET_ENTER_DATA_CLAUSE(map) |
| OPENMP_TARGET_ENTER_DATA_CLAUSE(nowait) |
| OPENMP_TARGET_ENTER_DATA_CLAUSE(depend) |
| |
| // Clauses allowed for OpenMP directive 'target exit data'. |
| OPENMP_TARGET_EXIT_DATA_CLAUSE(if) |
| OPENMP_TARGET_EXIT_DATA_CLAUSE(device) |
| OPENMP_TARGET_EXIT_DATA_CLAUSE(map) |
| OPENMP_TARGET_EXIT_DATA_CLAUSE(nowait) |
| OPENMP_TARGET_EXIT_DATA_CLAUSE(depend) |
| |
| // Clauses allowed for OpenMP directive 'target parallel'. |
| OPENMP_TARGET_PARALLEL_CLAUSE(if) |
| OPENMP_TARGET_PARALLEL_CLAUSE(device) |
| OPENMP_TARGET_PARALLEL_CLAUSE(map) |
| OPENMP_TARGET_PARALLEL_CLAUSE(private) |
| OPENMP_TARGET_PARALLEL_CLAUSE(firstprivate) |
| OPENMP_TARGET_PARALLEL_CLAUSE(nowait) |
| OPENMP_TARGET_PARALLEL_CLAUSE(depend) |
| OPENMP_TARGET_PARALLEL_CLAUSE(defaultmap) |
| OPENMP_TARGET_PARALLEL_CLAUSE(num_threads) |
| OPENMP_TARGET_PARALLEL_CLAUSE(default) |
| OPENMP_TARGET_PARALLEL_CLAUSE(proc_bind) |
| OPENMP_TARGET_PARALLEL_CLAUSE(shared) |
| OPENMP_TARGET_PARALLEL_CLAUSE(reduction) |
| OPENMP_TARGET_PARALLEL_CLAUSE(is_device_ptr) |
| |
| // Clauses allowed for OpenMP directive 'target parallel for'. |
| OPENMP_TARGET_PARALLEL_FOR_CLAUSE(if) |
| OPENMP_TARGET_PARALLEL_FOR_CLAUSE(device) |
| OPENMP_TARGET_PARALLEL_FOR_CLAUSE(map) |
| OPENMP_TARGET_PARALLEL_FOR_CLAUSE(private) |
| OPENMP_TARGET_PARALLEL_FOR_CLAUSE(firstprivate) |
| OPENMP_TARGET_PARALLEL_FOR_CLAUSE(lastprivate) |
| OPENMP_TARGET_PARALLEL_FOR_CLAUSE(nowait) |
| OPENMP_TARGET_PARALLEL_FOR_CLAUSE(depend) |
| OPENMP_TARGET_PARALLEL_FOR_CLAUSE(defaultmap) |
| OPENMP_TARGET_PARALLEL_FOR_CLAUSE(num_threads) |
| OPENMP_TARGET_PARALLEL_FOR_CLAUSE(default) |
| OPENMP_TARGET_PARALLEL_FOR_CLAUSE(proc_bind) |
| OPENMP_TARGET_PARALLEL_FOR_CLAUSE(shared) |
| OPENMP_TARGET_PARALLEL_FOR_CLAUSE(reduction) |
| OPENMP_TARGET_PARALLEL_FOR_CLAUSE(collapse) |
| OPENMP_TARGET_PARALLEL_FOR_CLAUSE(schedule) |
| OPENMP_TARGET_PARALLEL_FOR_CLAUSE(ordered) |
| OPENMP_TARGET_PARALLEL_FOR_CLAUSE(linear) |
| OPENMP_TARGET_PARALLEL_FOR_CLAUSE(is_device_ptr) |
| |
| // Clauses allowed for OpenMP directive 'target update'. |
| OPENMP_TARGET_UPDATE_CLAUSE(if) |
| OPENMP_TARGET_UPDATE_CLAUSE(device) |
| OPENMP_TARGET_UPDATE_CLAUSE(to) |
| OPENMP_TARGET_UPDATE_CLAUSE(from) |
| OPENMP_TARGET_UPDATE_CLAUSE(nowait) |
| OPENMP_TARGET_UPDATE_CLAUSE(depend) |
| |
| // Clauses allowed for OpenMP directive 'teams'. |
| OPENMP_TEAMS_CLAUSE(default) |
| OPENMP_TEAMS_CLAUSE(private) |
| OPENMP_TEAMS_CLAUSE(firstprivate) |
| OPENMP_TEAMS_CLAUSE(shared) |
| OPENMP_TEAMS_CLAUSE(reduction) |
| OPENMP_TEAMS_CLAUSE(num_teams) |
| OPENMP_TEAMS_CLAUSE(thread_limit) |
| |
| // Clauses allowed for OpenMP directive 'ordered'. |
| OPENMP_ORDERED_CLAUSE(threads) |
| OPENMP_ORDERED_CLAUSE(simd) |
| OPENMP_ORDERED_CLAUSE(depend) |
| |
| // Map types and map type modifier for 'map' clause. |
| OPENMP_MAP_KIND(alloc) |
| OPENMP_MAP_KIND(to) |
| OPENMP_MAP_KIND(from) |
| OPENMP_MAP_KIND(tofrom) |
| OPENMP_MAP_KIND(delete) |
| OPENMP_MAP_KIND(release) |
| OPENMP_MAP_KIND(always) |
| |
| // Clauses allowed for OpenMP directive 'taskloop'. |
| OPENMP_TASKLOOP_CLAUSE(if) |
| OPENMP_TASKLOOP_CLAUSE(shared) |
| OPENMP_TASKLOOP_CLAUSE(private) |
| OPENMP_TASKLOOP_CLAUSE(firstprivate) |
| OPENMP_TASKLOOP_CLAUSE(lastprivate) |
| OPENMP_TASKLOOP_CLAUSE(default) |
| OPENMP_TASKLOOP_CLAUSE(collapse) |
| OPENMP_TASKLOOP_CLAUSE(final) |
| OPENMP_TASKLOOP_CLAUSE(untied) |
| OPENMP_TASKLOOP_CLAUSE(mergeable) |
| OPENMP_TASKLOOP_CLAUSE(priority) |
| OPENMP_TASKLOOP_CLAUSE(grainsize) |
| OPENMP_TASKLOOP_CLAUSE(nogroup) |
| OPENMP_TASKLOOP_CLAUSE(num_tasks) |
| OPENMP_TASKLOOP_CLAUSE(reduction) |
| OPENMP_TASKLOOP_CLAUSE(in_reduction) |
| |
| // Clauses allowed for OpenMP directive 'taskloop simd'. |
| OPENMP_TASKLOOP_SIMD_CLAUSE(if) |
| OPENMP_TASKLOOP_SIMD_CLAUSE(shared) |
| OPENMP_TASKLOOP_SIMD_CLAUSE(private) |
| OPENMP_TASKLOOP_SIMD_CLAUSE(firstprivate) |
| OPENMP_TASKLOOP_SIMD_CLAUSE(lastprivate) |
| OPENMP_TASKLOOP_SIMD_CLAUSE(default) |
| OPENMP_TASKLOOP_SIMD_CLAUSE(collapse) |
| OPENMP_TASKLOOP_SIMD_CLAUSE(final) |
| OPENMP_TASKLOOP_SIMD_CLAUSE(untied) |
| OPENMP_TASKLOOP_SIMD_CLAUSE(mergeable) |
| OPENMP_TASKLOOP_SIMD_CLAUSE(priority) |
| OPENMP_TASKLOOP_SIMD_CLAUSE(linear) |
| OPENMP_TASKLOOP_SIMD_CLAUSE(aligned) |
| OPENMP_TASKLOOP_SIMD_CLAUSE(safelen) |
| OPENMP_TASKLOOP_SIMD_CLAUSE(simdlen) |
| OPENMP_TASKLOOP_SIMD_CLAUSE(grainsize) |
| OPENMP_TASKLOOP_SIMD_CLAUSE(nogroup) |
| OPENMP_TASKLOOP_SIMD_CLAUSE(num_tasks) |
| OPENMP_TASKLOOP_SIMD_CLAUSE(reduction) |
| OPENMP_TASKLOOP_SIMD_CLAUSE(in_reduction) |
| |
| // Clauses allowed for OpenMP directive 'critical'. |
| OPENMP_CRITICAL_CLAUSE(hint) |
| |
| // Clauses allowed for OpenMP directive 'distribute' |
| OPENMP_DISTRIBUTE_CLAUSE(private) |
| OPENMP_DISTRIBUTE_CLAUSE(firstprivate) |
| OPENMP_DISTRIBUTE_CLAUSE(lastprivate) |
| OPENMP_DISTRIBUTE_CLAUSE(collapse) |
| OPENMP_DISTRIBUTE_CLAUSE(dist_schedule) |
| |
| // Static attributes for 'dist_schedule' clause. |
| OPENMP_DIST_SCHEDULE_KIND(static) |
| |
| // Clauses allowed for OpenMP directive 'distribute parallel for' |
| OPENMP_DISTRIBUTE_PARALLEL_FOR_CLAUSE(firstprivate) |
| OPENMP_DISTRIBUTE_PARALLEL_FOR_CLAUSE(lastprivate) |
| OPENMP_DISTRIBUTE_PARALLEL_FOR_CLAUSE(collapse) |
| OPENMP_DISTRIBUTE_PARALLEL_FOR_CLAUSE(dist_schedule) |
| OPENMP_DISTRIBUTE_PARALLEL_FOR_CLAUSE(if) |
| OPENMP_DISTRIBUTE_PARALLEL_FOR_CLAUSE(num_threads) |
| OPENMP_DISTRIBUTE_PARALLEL_FOR_CLAUSE(default) |
| OPENMP_DISTRIBUTE_PARALLEL_FOR_CLAUSE(proc_bind) |
| OPENMP_DISTRIBUTE_PARALLEL_FOR_CLAUSE(private) |
| OPENMP_DISTRIBUTE_PARALLEL_FOR_CLAUSE(shared) |
| OPENMP_DISTRIBUTE_PARALLEL_FOR_CLAUSE(reduction) |
| OPENMP_DISTRIBUTE_PARALLEL_FOR_CLAUSE(copyin) |
| OPENMP_DISTRIBUTE_PARALLEL_FOR_CLAUSE(schedule) |
| |
| // Clauses allowed for OpenMP directive 'distribute parallel for simd' |
| OPENMP_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(firstprivate) |
| OPENMP_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(lastprivate) |
| OPENMP_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(collapse) |
| OPENMP_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(dist_schedule) |
| OPENMP_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(if) |
| OPENMP_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(num_threads) |
| OPENMP_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(default) |
| OPENMP_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(proc_bind) |
| OPENMP_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(private) |
| OPENMP_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(shared) |
| OPENMP_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(reduction) |
| OPENMP_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(copyin) |
| OPENMP_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(schedule) |
| OPENMP_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(linear) |
| OPENMP_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(aligned) |
| OPENMP_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(safelen) |
| OPENMP_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(simdlen) |
| |
| // Clauses allowed for OpenMP directive 'distribute simd' |
| OPENMP_DISTRIBUTE_SIMD_CLAUSE(private) |
| OPENMP_DISTRIBUTE_SIMD_CLAUSE(firstprivate) |
| OPENMP_DISTRIBUTE_SIMD_CLAUSE(lastprivate) |
| OPENMP_DISTRIBUTE_SIMD_CLAUSE(collapse) |
| OPENMP_DISTRIBUTE_SIMD_CLAUSE(dist_schedule) |
| OPENMP_DISTRIBUTE_SIMD_CLAUSE(linear) |
| OPENMP_DISTRIBUTE_SIMD_CLAUSE(aligned) |
| OPENMP_DISTRIBUTE_SIMD_CLAUSE(safelen) |
| OPENMP_DISTRIBUTE_SIMD_CLAUSE(simdlen) |
| OPENMP_DISTRIBUTE_SIMD_CLAUSE(reduction) |
| |
| // Clauses allowed for OpenMP directive 'target parallel for simd'. |
| OPENMP_TARGET_PARALLEL_FOR_SIMD_CLAUSE(if) |
| OPENMP_TARGET_PARALLEL_FOR_SIMD_CLAUSE(device) |
| OPENMP_TARGET_PARALLEL_FOR_SIMD_CLAUSE(map) |
| OPENMP_TARGET_PARALLEL_FOR_SIMD_CLAUSE(private) |
| OPENMP_TARGET_PARALLEL_FOR_SIMD_CLAUSE(firstprivate) |
| OPENMP_TARGET_PARALLEL_FOR_SIMD_CLAUSE(lastprivate) |
| OPENMP_TARGET_PARALLEL_FOR_SIMD_CLAUSE(nowait) |
| OPENMP_TARGET_PARALLEL_FOR_SIMD_CLAUSE(depend) |
| OPENMP_TARGET_PARALLEL_FOR_SIMD_CLAUSE(defaultmap) |
| OPENMP_TARGET_PARALLEL_FOR_SIMD_CLAUSE(num_threads) |
| OPENMP_TARGET_PARALLEL_FOR_SIMD_CLAUSE(default) |
| OPENMP_TARGET_PARALLEL_FOR_SIMD_CLAUSE(proc_bind) |
| OPENMP_TARGET_PARALLEL_FOR_SIMD_CLAUSE(shared) |
| OPENMP_TARGET_PARALLEL_FOR_SIMD_CLAUSE(reduction) |
| OPENMP_TARGET_PARALLEL_FOR_SIMD_CLAUSE(collapse) |
| OPENMP_TARGET_PARALLEL_FOR_SIMD_CLAUSE(schedule) |
| OPENMP_TARGET_PARALLEL_FOR_SIMD_CLAUSE(ordered) |
| OPENMP_TARGET_PARALLEL_FOR_SIMD_CLAUSE(linear) |
| OPENMP_TARGET_PARALLEL_FOR_SIMD_CLAUSE(safelen) |
| OPENMP_TARGET_PARALLEL_FOR_SIMD_CLAUSE(simdlen) |
| OPENMP_TARGET_PARALLEL_FOR_SIMD_CLAUSE(aligned) |
| OPENMP_TARGET_PARALLEL_FOR_SIMD_CLAUSE(is_device_ptr) |
| |
| // Clauses allowed for OpenMP directive 'target simd'. |
| OPENMP_TARGET_SIMD_CLAUSE(if) |
| OPENMP_TARGET_SIMD_CLAUSE(device) |
| OPENMP_TARGET_SIMD_CLAUSE(map) |
| OPENMP_TARGET_SIMD_CLAUSE(private) |
| OPENMP_TARGET_SIMD_CLAUSE(nowait) |
| OPENMP_TARGET_SIMD_CLAUSE(depend) |
| OPENMP_TARGET_SIMD_CLAUSE(defaultmap) |
| OPENMP_TARGET_SIMD_CLAUSE(firstprivate) |
| OPENMP_TARGET_SIMD_CLAUSE(is_device_ptr) |
| OPENMP_TARGET_SIMD_CLAUSE(lastprivate) |
| OPENMP_TARGET_SIMD_CLAUSE(linear) |
| OPENMP_TARGET_SIMD_CLAUSE(aligned) |
| OPENMP_TARGET_SIMD_CLAUSE(safelen) |
| OPENMP_TARGET_SIMD_CLAUSE(simdlen) |
| OPENMP_TARGET_SIMD_CLAUSE(collapse) |
| OPENMP_TARGET_SIMD_CLAUSE(reduction) |
| |
| // Clauses allowed for OpenMP directive 'teams distribute'. |
| OPENMP_TEAMS_DISTRIBUTE_CLAUSE(default) |
| OPENMP_TEAMS_DISTRIBUTE_CLAUSE(private) |
| OPENMP_TEAMS_DISTRIBUTE_CLAUSE(firstprivate) |
| OPENMP_TEAMS_DISTRIBUTE_CLAUSE(shared) |
| OPENMP_TEAMS_DISTRIBUTE_CLAUSE(reduction) |
| OPENMP_TEAMS_DISTRIBUTE_CLAUSE(num_teams) |
| OPENMP_TEAMS_DISTRIBUTE_CLAUSE(thread_limit) |
| OPENMP_TEAMS_DISTRIBUTE_CLAUSE(lastprivate) |
| OPENMP_TEAMS_DISTRIBUTE_CLAUSE(collapse) |
| OPENMP_TEAMS_DISTRIBUTE_CLAUSE(dist_schedule) |
| |
| // Clauses allowed for OpenMP directive 'teams distribute simd' |
| OPENMP_TEAMS_DISTRIBUTE_SIMD_CLAUSE(default) |
| OPENMP_TEAMS_DISTRIBUTE_SIMD_CLAUSE(private) |
| OPENMP_TEAMS_DISTRIBUTE_SIMD_CLAUSE(firstprivate) |
| OPENMP_TEAMS_DISTRIBUTE_SIMD_CLAUSE(shared) |
| OPENMP_TEAMS_DISTRIBUTE_SIMD_CLAUSE(reduction) |
| OPENMP_TEAMS_DISTRIBUTE_SIMD_CLAUSE(num_teams) |
| OPENMP_TEAMS_DISTRIBUTE_SIMD_CLAUSE(thread_limit) |
| OPENMP_TEAMS_DISTRIBUTE_SIMD_CLAUSE(lastprivate) |
| OPENMP_TEAMS_DISTRIBUTE_SIMD_CLAUSE(collapse) |
| OPENMP_TEAMS_DISTRIBUTE_SIMD_CLAUSE(dist_schedule) |
| OPENMP_TEAMS_DISTRIBUTE_SIMD_CLAUSE(linear) |
| OPENMP_TEAMS_DISTRIBUTE_SIMD_CLAUSE(aligned) |
| OPENMP_TEAMS_DISTRIBUTE_SIMD_CLAUSE(safelen) |
| OPENMP_TEAMS_DISTRIBUTE_SIMD_CLAUSE(simdlen) |
| |
| // Clauses allowed for OpenMP directive 'teams distribute parallel for simd' |
| OPENMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(firstprivate) |
| OPENMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(lastprivate) |
| OPENMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(collapse) |
| OPENMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(dist_schedule) |
| OPENMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(if) |
| OPENMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(num_threads) |
| OPENMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(default) |
| OPENMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(proc_bind) |
| OPENMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(private) |
| OPENMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(shared) |
| OPENMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(reduction) |
| OPENMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(schedule) |
| OPENMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(linear) |
| OPENMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(aligned) |
| OPENMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(safelen) |
| OPENMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(simdlen) |
| OPENMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(num_teams) |
| OPENMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(thread_limit) |
| |
| // Clauses allowed for OpenMP directive 'teams distribute parallel for' |
| OPENMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_CLAUSE(firstprivate) |
| OPENMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_CLAUSE(lastprivate) |
| OPENMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_CLAUSE(collapse) |
| OPENMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_CLAUSE(dist_schedule) |
| OPENMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_CLAUSE(if) |
| OPENMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_CLAUSE(num_threads) |
| OPENMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_CLAUSE(default) |
| OPENMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_CLAUSE(proc_bind) |
| OPENMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_CLAUSE(private) |
| OPENMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_CLAUSE(shared) |
| OPENMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_CLAUSE(reduction) |
| OPENMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_CLAUSE(schedule) |
| OPENMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_CLAUSE(num_teams) |
| OPENMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_CLAUSE(thread_limit) |
| OPENMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_CLAUSE(copyin) |
| |
| // Clauses allowed for OpenMP directive 'target teams'. |
| OPENMP_TARGET_TEAMS_CLAUSE(if) |
| OPENMP_TARGET_TEAMS_CLAUSE(device) |
| OPENMP_TARGET_TEAMS_CLAUSE(map) |
| OPENMP_TARGET_TEAMS_CLAUSE(private) |
| OPENMP_TARGET_TEAMS_CLAUSE(nowait) |
| OPENMP_TARGET_TEAMS_CLAUSE(depend) |
| OPENMP_TARGET_TEAMS_CLAUSE(defaultmap) |
| OPENMP_TARGET_TEAMS_CLAUSE(firstprivate) |
| OPENMP_TARGET_TEAMS_CLAUSE(is_device_ptr) |
| OPENMP_TARGET_TEAMS_CLAUSE(default) |
| OPENMP_TARGET_TEAMS_CLAUSE(shared) |
| OPENMP_TARGET_TEAMS_CLAUSE(reduction) |
| OPENMP_TARGET_TEAMS_CLAUSE(num_teams) |
| OPENMP_TARGET_TEAMS_CLAUSE(thread_limit) |
| |
| // Clauses allowed for OpenMP directive 'target teams distribute'. |
| OPENMP_TARGET_TEAMS_DISTRIBUTE_CLAUSE(if) |
| OPENMP_TARGET_TEAMS_DISTRIBUTE_CLAUSE(device) |
| OPENMP_TARGET_TEAMS_DISTRIBUTE_CLAUSE(map) |
| OPENMP_TARGET_TEAMS_DISTRIBUTE_CLAUSE(private) |
| OPENMP_TARGET_TEAMS_DISTRIBUTE_CLAUSE(nowait) |
| OPENMP_TARGET_TEAMS_DISTRIBUTE_CLAUSE(depend) |
| OPENMP_TARGET_TEAMS_DISTRIBUTE_CLAUSE(defaultmap) |
| OPENMP_TARGET_TEAMS_DISTRIBUTE_CLAUSE(firstprivate) |
| OPENMP_TARGET_TEAMS_DISTRIBUTE_CLAUSE(is_device_ptr) |
| OPENMP_TARGET_TEAMS_DISTRIBUTE_CLAUSE(default) |
| OPENMP_TARGET_TEAMS_DISTRIBUTE_CLAUSE(shared) |
| OPENMP_TARGET_TEAMS_DISTRIBUTE_CLAUSE(reduction) |
| OPENMP_TARGET_TEAMS_DISTRIBUTE_CLAUSE(num_teams) |
| OPENMP_TARGET_TEAMS_DISTRIBUTE_CLAUSE(thread_limit) |
| OPENMP_TARGET_TEAMS_DISTRIBUTE_CLAUSE(lastprivate) |
| OPENMP_TARGET_TEAMS_DISTRIBUTE_CLAUSE(collapse) |
| OPENMP_TARGET_TEAMS_DISTRIBUTE_CLAUSE(dist_schedule) |
| |
| // Clauses allowed for OpenMP directive 'target teams distribute parallel for'. |
| OPENMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_CLAUSE(if) |
| OPENMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_CLAUSE(device) |
| OPENMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_CLAUSE(map) |
| OPENMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_CLAUSE(private) |
| OPENMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_CLAUSE(nowait) |
| OPENMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_CLAUSE(depend) |
| OPENMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_CLAUSE(defaultmap) |
| OPENMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_CLAUSE(firstprivate) |
| OPENMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_CLAUSE(is_device_ptr) |
| OPENMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_CLAUSE(default) |
| OPENMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_CLAUSE(shared) |
| OPENMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_CLAUSE(reduction) |
| OPENMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_CLAUSE(num_teams) |
| OPENMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_CLAUSE(thread_limit) |
| OPENMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_CLAUSE(lastprivate) |
| OPENMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_CLAUSE(collapse) |
| OPENMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_CLAUSE(dist_schedule) |
| OPENMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_CLAUSE(num_threads) |
| OPENMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_CLAUSE(proc_bind) |
| OPENMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_CLAUSE(schedule) |
| |
| // Clauses allowed for OpenMP directive |
| // 'target teams distribute parallel for simd'. |
| OPENMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(if) |
| OPENMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(device) |
| OPENMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(map) |
| OPENMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(private) |
| OPENMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(nowait) |
| OPENMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(depend) |
| OPENMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(defaultmap) |
| OPENMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(firstprivate) |
| OPENMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(is_device_ptr) |
| OPENMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(default) |
| OPENMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(shared) |
| OPENMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(reduction) |
| OPENMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(num_teams) |
| OPENMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(thread_limit) |
| OPENMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(lastprivate) |
| OPENMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(collapse) |
| OPENMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(dist_schedule) |
| OPENMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(num_threads) |
| OPENMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(proc_bind) |
| OPENMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(schedule) |
| OPENMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(linear) |
| OPENMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(aligned) |
| OPENMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(safelen) |
| OPENMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(simdlen) |
| |
| // Clauses allowed for OpenMP directive 'target teams distribute simd'. |
| OPENMP_TARGET_TEAMS_DISTRIBUTE_SIMD_CLAUSE(if) |
| OPENMP_TARGET_TEAMS_DISTRIBUTE_SIMD_CLAUSE(device) |
| OPENMP_TARGET_TEAMS_DISTRIBUTE_SIMD_CLAUSE(map) |
| OPENMP_TARGET_TEAMS_DISTRIBUTE_SIMD_CLAUSE(private) |
| OPENMP_TARGET_TEAMS_DISTRIBUTE_SIMD_CLAUSE(nowait) |
| OPENMP_TARGET_TEAMS_DISTRIBUTE_SIMD_CLAUSE(depend) |
| OPENMP_TARGET_TEAMS_DISTRIBUTE_SIMD_CLAUSE(defaultmap) |
| OPENMP_TARGET_TEAMS_DISTRIBUTE_SIMD_CLAUSE(firstprivate) |
| OPENMP_TARGET_TEAMS_DISTRIBUTE_SIMD_CLAUSE(lastprivate) |
| OPENMP_TARGET_TEAMS_DISTRIBUTE_SIMD_CLAUSE(is_device_ptr) |
| OPENMP_TARGET_TEAMS_DISTRIBUTE_SIMD_CLAUSE(shared) |
| OPENMP_TARGET_TEAMS_DISTRIBUTE_SIMD_CLAUSE(reduction) |
| OPENMP_TARGET_TEAMS_DISTRIBUTE_SIMD_CLAUSE(num_teams) |
| OPENMP_TARGET_TEAMS_DISTRIBUTE_SIMD_CLAUSE(thread_limit) |
| OPENMP_TARGET_TEAMS_DISTRIBUTE_SIMD_CLAUSE(collapse) |
| OPENMP_TARGET_TEAMS_DISTRIBUTE_SIMD_CLAUSE(dist_schedule) |
| OPENMP_TARGET_TEAMS_DISTRIBUTE_SIMD_CLAUSE(linear) |
| OPENMP_TARGET_TEAMS_DISTRIBUTE_SIMD_CLAUSE(aligned) |
| OPENMP_TARGET_TEAMS_DISTRIBUTE_SIMD_CLAUSE(safelen) |
| OPENMP_TARGET_TEAMS_DISTRIBUTE_SIMD_CLAUSE(simdlen) |
| |
| // Clauses allowed for OpenMP directive 'taskgroup'. |
| OPENMP_TASKGROUP_CLAUSE(task_reduction) |
| |
| #undef OPENMP_TASKGROUP_CLAUSE |
| #undef OPENMP_TASKLOOP_SIMD_CLAUSE |
| #undef OPENMP_TASKLOOP_CLAUSE |
| #undef OPENMP_LINEAR_KIND |
| #undef OPENMP_DEPEND_KIND |
| #undef OPENMP_SCHEDULE_MODIFIER |
| #undef OPENMP_SCHEDULE_KIND |
| #undef OPENMP_PROC_BIND_KIND |
| #undef OPENMP_DEFAULT_KIND |
| #undef OPENMP_DIRECTIVE |
| #undef OPENMP_DIRECTIVE_EXT |
| #undef OPENMP_CLAUSE |
| #undef OPENMP_CRITICAL_CLAUSE |
| #undef OPENMP_ORDERED_CLAUSE |
| #undef OPENMP_CANCEL_CLAUSE |
| #undef OPENMP_SINGLE_CLAUSE |
| #undef OPENMP_SECTIONS_CLAUSE |
| #undef OPENMP_PARALLEL_CLAUSE |
| #undef OPENMP_PARALLEL_FOR_CLAUSE |
| #undef OPENMP_PARALLEL_FOR_SIMD_CLAUSE |
| #undef OPENMP_PARALLEL_SECTIONS_CLAUSE |
| #undef OPENMP_TASK_CLAUSE |
| #undef OPENMP_ATOMIC_CLAUSE |
| #undef OPENMP_TARGET_CLAUSE |
| #undef OPENMP_TARGET_DATA_CLAUSE |
| #undef OPENMP_TARGET_ENTER_DATA_CLAUSE |
| #undef OPENMP_TARGET_EXIT_DATA_CLAUSE |
| #undef OPENMP_TARGET_PARALLEL_CLAUSE |
| #undef OPENMP_TARGET_PARALLEL_FOR_CLAUSE |
| #undef OPENMP_TEAMS_CLAUSE |
| #undef OPENMP_SIMD_CLAUSE |
| #undef OPENMP_FOR_CLAUSE |
| #undef OPENMP_FOR_SIMD_CLAUSE |
| #undef OPENMP_MAP_KIND |
| #undef OPENMP_DISTRIBUTE_CLAUSE |
| #undef OPENMP_DIST_SCHEDULE_KIND |
| #undef OPENMP_DEFAULTMAP_KIND |
| #undef OPENMP_DEFAULTMAP_MODIFIER |
| #undef OPENMP_TARGET_UPDATE_CLAUSE |
| #undef OPENMP_DISTRIBUTE_PARALLEL_FOR_CLAUSE |
| #undef OPENMP_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE |
| #undef OPENMP_DISTRIBUTE_SIMD_CLAUSE |
| #undef OPENMP_TARGET_PARALLEL_FOR_SIMD_CLAUSE |
| #undef OPENMP_TARGET_SIMD_CLAUSE |
| #undef OPENMP_TEAMS_DISTRIBUTE_CLAUSE |
| #undef OPENMP_TEAMS_DISTRIBUTE_SIMD_CLAUSE |
| #undef OPENMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE |
| #undef OPENMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_CLAUSE |
| #undef OPENMP_TARGET_TEAMS_CLAUSE |
| #undef OPENMP_TARGET_TEAMS_DISTRIBUTE_CLAUSE |
| #undef OPENMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_CLAUSE |
| #undef OPENMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE |
| #undef OPENMP_TARGET_TEAMS_DISTRIBUTE_SIMD_CLAUSE |
