| //===--- OpenMPKinds.def - OpenMP directives and clauses list ---*- 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 directives and |
| /// clauses. |
| /// |
| //===----------------------------------------------------------------------===// |
| |
| #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_MASTER_CLAUSE |
| # define OPENMP_PARALLEL_MASTER_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_REQUIRES_CLAUSE |
| # define OPENMP_REQUIRES_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_MASTER_TASKLOOP_CLAUSE |
| # define OPENMP_MASTER_TASKLOOP_CLAUSE(Name) |
| #endif |
| #ifndef OPENMP_MASTER_TASKLOOP_SIMD_CLAUSE |
| # define OPENMP_MASTER_TASKLOOP_SIMD_CLAUSE(Name) |
| #endif |
| #ifndef OPENMP_PARALLEL_MASTER_TASKLOOP_CLAUSE |
| # define OPENMP_PARALLEL_MASTER_TASKLOOP_CLAUSE(Name) |
| #endif |
| #ifndef OPENMP_PARALLEL_MASTER_TASKLOOP_SIMD_CLAUSE |
| # define OPENMP_PARALLEL_MASTER_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_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_MAP_MODIFIER_KIND |
| #define OPENMP_MAP_MODIFIER_KIND(Name) |
| #endif |
| #ifndef OPENMP_TO_MODIFIER_KIND |
| #define OPENMP_TO_MODIFIER_KIND(Name) |
| #endif |
| #ifndef OPENMP_FROM_MODIFIER_KIND |
| #define OPENMP_FROM_MODIFIER_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_ATOMIC_DEFAULT_MEM_ORDER_KIND |
| #define OPENMP_ATOMIC_DEFAULT_MEM_ORDER_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 |
| #ifndef OPENMP_DECLARE_MAPPER_CLAUSE |
| #define OPENMP_DECLARE_MAPPER_CLAUSE(Name) |
| #endif |
| #ifndef OPENMP_ALLOCATE_CLAUSE |
| # define OPENMP_ALLOCATE_CLAUSE(Name) |
| #endif |
| #ifndef OPENMP_DEVICE_TYPE_KIND |
| #define OPENMP_DEVICE_TYPE_KIND(Name) |
| #endif |
| #ifndef OPENMP_DECLARE_VARIANT_CLAUSE |
| #define OPENMP_DECLARE_VARIANT_CLAUSE(Name) |
| #endif |
| #ifndef OPENMP_LASTPRIVATE_KIND |
| #define OPENMP_LASTPRIVATE_KIND(Name) |
| #endif |
| #ifndef OPENMP_ORDER_KIND |
| #define OPENMP_ORDER_KIND(Name) |
| #endif |
| #ifndef OPENMP_FLUSH_CLAUSE |
| #define OPENMP_FLUSH_CLAUSE(Name) |
| #endif |
| #ifndef OPENMP_DEPOBJ_CLAUSE |
| #define OPENMP_DEPOBJ_CLAUSE(Name) |
| #endif |
| #ifndef OPENMP_DEVICE_MODIFIER |
| #define OPENMP_DEVICE_MODIFIER(Name) |
| #endif |
| #ifndef OPENMP_SCAN_CLAUSE |
| #define OPENMP_SCAN_CLAUSE(Name) |
| #endif |
| #ifndef OPENMP_REDUCTION_MODIFIER |
| #define OPENMP_REDUCTION_MODIFIER(Name) |
| #endif |
| |
| // Clauses allowed for OpenMP directive 'scan'. |
| OPENMP_SCAN_CLAUSE(inclusive) |
| OPENMP_SCAN_CLAUSE(exclusive) |
| |
| // 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) |
| OPENMP_PARALLEL_CLAUSE(allocate) |
| |
| // 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) |
| OPENMP_SIMD_CLAUSE(allocate) |
| OPENMP_SIMD_CLAUSE(if) |
| OPENMP_SIMD_CLAUSE(nontemporal) |
| OPENMP_SIMD_CLAUSE(order) |
| |
| // 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) |
| OPENMP_FOR_CLAUSE(allocate) |
| OPENMP_FOR_CLAUSE(order) |
| |
| // 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) |
| OPENMP_FOR_SIMD_CLAUSE(allocate) |
| OPENMP_FOR_SIMD_CLAUSE(if) |
| OPENMP_FOR_SIMD_CLAUSE(nontemporal) |
| OPENMP_FOR_SIMD_CLAUSE(order) |
| |
| // 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) |
| OPENMP_SECTIONS_CLAUSE(allocate) |
| |
| // Clauses allowed for directive 'omp single'. |
| OPENMP_SINGLE_CLAUSE(private) |
| OPENMP_SINGLE_CLAUSE(firstprivate) |
| OPENMP_SINGLE_CLAUSE(copyprivate) |
| OPENMP_SINGLE_CLAUSE(nowait) |
| OPENMP_SINGLE_CLAUSE(allocate) |
| |
| // Clauses allowed for OpenMP directive 'cancel'. |
| OPENMP_CANCEL_CLAUSE(if) |
| |
| // 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) |
| |
| // Modifiers for 'device' clause. |
| OPENMP_DEVICE_MODIFIER(ancestor) |
| OPENMP_DEVICE_MODIFIER(device_num) |
| |
| // Static attributes for 'defaultmap' clause. |
| OPENMP_DEFAULTMAP_KIND(scalar) |
| OPENMP_DEFAULTMAP_KIND(aggregate) |
| OPENMP_DEFAULTMAP_KIND(pointer) |
| |
| // Modifiers for 'defaultmap' clause. |
| OPENMP_DEFAULTMAP_MODIFIER(alloc) |
| OPENMP_DEFAULTMAP_MODIFIER(to) |
| OPENMP_DEFAULTMAP_MODIFIER(from) |
| OPENMP_DEFAULTMAP_MODIFIER(tofrom) |
| OPENMP_DEFAULTMAP_MODIFIER(firstprivate) |
| OPENMP_DEFAULTMAP_MODIFIER(none) |
| OPENMP_DEFAULTMAP_MODIFIER(default) |
| |
| // Static attributes for 'depend' clause. |
| OPENMP_DEPEND_KIND(in) |
| OPENMP_DEPEND_KIND(out) |
| OPENMP_DEPEND_KIND(inout) |
| OPENMP_DEPEND_KIND(mutexinoutset) |
| OPENMP_DEPEND_KIND(depobj) |
| 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) |
| OPENMP_PARALLEL_FOR_CLAUSE(allocate) |
| OPENMP_PARALLEL_FOR_CLAUSE(order) |
| |
| // 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) |
| OPENMP_PARALLEL_FOR_SIMD_CLAUSE(allocate) |
| OPENMP_PARALLEL_FOR_SIMD_CLAUSE(nontemporal) |
| OPENMP_PARALLEL_FOR_SIMD_CLAUSE(order) |
| |
| // Clauses allowed for OpenMP directive 'parallel master'. |
| OPENMP_PARALLEL_MASTER_CLAUSE(if) |
| OPENMP_PARALLEL_MASTER_CLAUSE(num_threads) |
| OPENMP_PARALLEL_MASTER_CLAUSE(default) |
| OPENMP_PARALLEL_MASTER_CLAUSE(private) |
| OPENMP_PARALLEL_MASTER_CLAUSE(firstprivate) |
| OPENMP_PARALLEL_MASTER_CLAUSE(shared) |
| OPENMP_PARALLEL_MASTER_CLAUSE(copyin) |
| OPENMP_PARALLEL_MASTER_CLAUSE(reduction) |
| OPENMP_PARALLEL_MASTER_CLAUSE(proc_bind) |
| OPENMP_PARALLEL_MASTER_CLAUSE(allocate) |
| |
| // 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) |
| OPENMP_PARALLEL_SECTIONS_CLAUSE(allocate) |
| |
| // 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) |
| OPENMP_TASK_CLAUSE(allocate) |
| OPENMP_TASK_CLAUSE(detach) |
| |
| // 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) |
| OPENMP_ATOMIC_CLAUSE(acq_rel) |
| OPENMP_ATOMIC_CLAUSE(acquire) |
| OPENMP_ATOMIC_CLAUSE(release) |
| OPENMP_ATOMIC_CLAUSE(relaxed) |
| OPENMP_ATOMIC_CLAUSE(hint) |
| |
| // 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) |
| OPENMP_TARGET_CLAUSE(allocate) |
| |
| // Clauses allowed for OpenMP directive 'requires'. |
| OPENMP_REQUIRES_CLAUSE(unified_address) |
| OPENMP_REQUIRES_CLAUSE(unified_shared_memory) |
| OPENMP_REQUIRES_CLAUSE(reverse_offload) |
| OPENMP_REQUIRES_CLAUSE(dynamic_allocators) |
| OPENMP_REQUIRES_CLAUSE(atomic_default_mem_order) |
| |
| // Clauses allowed for OpenMP directive 'allocate'. |
| OPENMP_ALLOCATE_CLAUSE(allocator) |
| |
| // Modifiers for 'atomic_default_mem_order' clause. |
| OPENMP_ATOMIC_DEFAULT_MEM_ORDER_KIND(seq_cst) |
| OPENMP_ATOMIC_DEFAULT_MEM_ORDER_KIND(acq_rel) |
| OPENMP_ATOMIC_DEFAULT_MEM_ORDER_KIND(relaxed) |
| |
| // 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) |
| OPENMP_TARGET_PARALLEL_CLAUSE(allocate) |
| |
| // 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) |
| OPENMP_TARGET_PARALLEL_FOR_CLAUSE(allocate) |
| OPENMP_TARGET_PARALLEL_FOR_CLAUSE(order) |
| |
| // 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) |
| OPENMP_TEAMS_CLAUSE(allocate) |
| |
| // Clauses allowed for OpenMP directive 'ordered'. |
| OPENMP_ORDERED_CLAUSE(threads) |
| OPENMP_ORDERED_CLAUSE(simd) |
| OPENMP_ORDERED_CLAUSE(depend) |
| |
| // Map types 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) |
| |
| // Map-type-modifiers for 'map' clause. |
| OPENMP_MAP_MODIFIER_KIND(always) |
| OPENMP_MAP_MODIFIER_KIND(close) |
| OPENMP_MAP_MODIFIER_KIND(mapper) |
| |
| // Modifiers for 'to' clause. |
| OPENMP_TO_MODIFIER_KIND(mapper) |
| |
| // Modifiers for 'from' clause. |
| OPENMP_FROM_MODIFIER_KIND(mapper) |
| |
| // 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) |
| OPENMP_TASKLOOP_CLAUSE(allocate) |
| |
| // 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) |
| OPENMP_TASKLOOP_SIMD_CLAUSE(allocate) |
| OPENMP_TASKLOOP_SIMD_CLAUSE(nontemporal) |
| OPENMP_TASKLOOP_SIMD_CLAUSE(order) |
| |
| // Clauses allowed for OpenMP directive 'master taskloop'. |
| OPENMP_MASTER_TASKLOOP_CLAUSE(if) |
| OPENMP_MASTER_TASKLOOP_CLAUSE(shared) |
| OPENMP_MASTER_TASKLOOP_CLAUSE(private) |
| OPENMP_MASTER_TASKLOOP_CLAUSE(firstprivate) |
| OPENMP_MASTER_TASKLOOP_CLAUSE(lastprivate) |
| OPENMP_MASTER_TASKLOOP_CLAUSE(default) |
| OPENMP_MASTER_TASKLOOP_CLAUSE(collapse) |
| OPENMP_MASTER_TASKLOOP_CLAUSE(final) |
| OPENMP_MASTER_TASKLOOP_CLAUSE(untied) |
| OPENMP_MASTER_TASKLOOP_CLAUSE(mergeable) |
| OPENMP_MASTER_TASKLOOP_CLAUSE(priority) |
| OPENMP_MASTER_TASKLOOP_CLAUSE(grainsize) |
| OPENMP_MASTER_TASKLOOP_CLAUSE(nogroup) |
| OPENMP_MASTER_TASKLOOP_CLAUSE(num_tasks) |
| OPENMP_MASTER_TASKLOOP_CLAUSE(reduction) |
| OPENMP_MASTER_TASKLOOP_CLAUSE(in_reduction) |
| OPENMP_MASTER_TASKLOOP_CLAUSE(allocate) |
| |
| // Clauses allowed for OpenMP directive 'master taskloop simd'. |
| OPENMP_MASTER_TASKLOOP_SIMD_CLAUSE(if) |
| OPENMP_MASTER_TASKLOOP_SIMD_CLAUSE(shared) |
| OPENMP_MASTER_TASKLOOP_SIMD_CLAUSE(private) |
| OPENMP_MASTER_TASKLOOP_SIMD_CLAUSE(firstprivate) |
| OPENMP_MASTER_TASKLOOP_SIMD_CLAUSE(lastprivate) |
| OPENMP_MASTER_TASKLOOP_SIMD_CLAUSE(default) |
| OPENMP_MASTER_TASKLOOP_SIMD_CLAUSE(collapse) |
| OPENMP_MASTER_TASKLOOP_SIMD_CLAUSE(final) |
| OPENMP_MASTER_TASKLOOP_SIMD_CLAUSE(untied) |
| OPENMP_MASTER_TASKLOOP_SIMD_CLAUSE(mergeable) |
| OPENMP_MASTER_TASKLOOP_SIMD_CLAUSE(priority) |
| OPENMP_MASTER_TASKLOOP_SIMD_CLAUSE(linear) |
| OPENMP_MASTER_TASKLOOP_SIMD_CLAUSE(aligned) |
| OPENMP_MASTER_TASKLOOP_SIMD_CLAUSE(safelen) |
| OPENMP_MASTER_TASKLOOP_SIMD_CLAUSE(simdlen) |
| OPENMP_MASTER_TASKLOOP_SIMD_CLAUSE(grainsize) |
| OPENMP_MASTER_TASKLOOP_SIMD_CLAUSE(nogroup) |
| OPENMP_MASTER_TASKLOOP_SIMD_CLAUSE(num_tasks) |
| OPENMP_MASTER_TASKLOOP_SIMD_CLAUSE(reduction) |
| OPENMP_MASTER_TASKLOOP_SIMD_CLAUSE(in_reduction) |
| OPENMP_MASTER_TASKLOOP_SIMD_CLAUSE(allocate) |
| OPENMP_MASTER_TASKLOOP_SIMD_CLAUSE(nontemporal) |
| OPENMP_MASTER_TASKLOOP_SIMD_CLAUSE(order) |
| |
| // Clauses allowed for OpenMP directive 'parallel master taskloop'. |
| OPENMP_PARALLEL_MASTER_TASKLOOP_CLAUSE(if) |
| OPENMP_PARALLEL_MASTER_TASKLOOP_CLAUSE(shared) |
| OPENMP_PARALLEL_MASTER_TASKLOOP_CLAUSE(private) |
| OPENMP_PARALLEL_MASTER_TASKLOOP_CLAUSE(firstprivate) |
| OPENMP_PARALLEL_MASTER_TASKLOOP_CLAUSE(lastprivate) |
| OPENMP_PARALLEL_MASTER_TASKLOOP_CLAUSE(default) |
| OPENMP_PARALLEL_MASTER_TASKLOOP_CLAUSE(collapse) |
| OPENMP_PARALLEL_MASTER_TASKLOOP_CLAUSE(final) |
| OPENMP_PARALLEL_MASTER_TASKLOOP_CLAUSE(untied) |
| OPENMP_PARALLEL_MASTER_TASKLOOP_CLAUSE(mergeable) |
| OPENMP_PARALLEL_MASTER_TASKLOOP_CLAUSE(priority) |
| OPENMP_PARALLEL_MASTER_TASKLOOP_CLAUSE(grainsize) |
| OPENMP_PARALLEL_MASTER_TASKLOOP_CLAUSE(nogroup) |
| OPENMP_PARALLEL_MASTER_TASKLOOP_CLAUSE(num_tasks) |
| OPENMP_PARALLEL_MASTER_TASKLOOP_CLAUSE(reduction) |
| OPENMP_PARALLEL_MASTER_TASKLOOP_CLAUSE(allocate) |
| OPENMP_PARALLEL_MASTER_TASKLOOP_CLAUSE(num_threads) |
| OPENMP_PARALLEL_MASTER_TASKLOOP_CLAUSE(proc_bind) |
| OPENMP_PARALLEL_MASTER_TASKLOOP_CLAUSE(copyin) |
| |
| // Clauses allowed for OpenMP directive 'parallel master taskloop simd'. |
| OPENMP_PARALLEL_MASTER_TASKLOOP_SIMD_CLAUSE(if) |
| OPENMP_PARALLEL_MASTER_TASKLOOP_SIMD_CLAUSE(shared) |
| OPENMP_PARALLEL_MASTER_TASKLOOP_SIMD_CLAUSE(private) |
| OPENMP_PARALLEL_MASTER_TASKLOOP_SIMD_CLAUSE(firstprivate) |
| OPENMP_PARALLEL_MASTER_TASKLOOP_SIMD_CLAUSE(lastprivate) |
| OPENMP_PARALLEL_MASTER_TASKLOOP_SIMD_CLAUSE(default) |
| OPENMP_PARALLEL_MASTER_TASKLOOP_SIMD_CLAUSE(collapse) |
| OPENMP_PARALLEL_MASTER_TASKLOOP_SIMD_CLAUSE(final) |
| OPENMP_PARALLEL_MASTER_TASKLOOP_SIMD_CLAUSE(untied) |
| OPENMP_PARALLEL_MASTER_TASKLOOP_SIMD_CLAUSE(mergeable) |
| OPENMP_PARALLEL_MASTER_TASKLOOP_SIMD_CLAUSE(priority) |
| OPENMP_PARALLEL_MASTER_TASKLOOP_SIMD_CLAUSE(grainsize) |
| OPENMP_PARALLEL_MASTER_TASKLOOP_SIMD_CLAUSE(nogroup) |
| OPENMP_PARALLEL_MASTER_TASKLOOP_SIMD_CLAUSE(num_tasks) |
| OPENMP_PARALLEL_MASTER_TASKLOOP_SIMD_CLAUSE(reduction) |
| OPENMP_PARALLEL_MASTER_TASKLOOP_SIMD_CLAUSE(allocate) |
| OPENMP_PARALLEL_MASTER_TASKLOOP_SIMD_CLAUSE(num_threads) |
| OPENMP_PARALLEL_MASTER_TASKLOOP_SIMD_CLAUSE(proc_bind) |
| OPENMP_PARALLEL_MASTER_TASKLOOP_SIMD_CLAUSE(copyin) |
| OPENMP_PARALLEL_MASTER_TASKLOOP_SIMD_CLAUSE(linear) |
| OPENMP_PARALLEL_MASTER_TASKLOOP_SIMD_CLAUSE(aligned) |
| OPENMP_PARALLEL_MASTER_TASKLOOP_SIMD_CLAUSE(safelen) |
| OPENMP_PARALLEL_MASTER_TASKLOOP_SIMD_CLAUSE(simdlen) |
| OPENMP_PARALLEL_MASTER_TASKLOOP_SIMD_CLAUSE(nontemporal) |
| OPENMP_PARALLEL_MASTER_TASKLOOP_SIMD_CLAUSE(order) |
| |
| // 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) |
| OPENMP_DISTRIBUTE_CLAUSE(allocate) |
| |
| // 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) |
| OPENMP_DISTRIBUTE_PARALLEL_FOR_CLAUSE(allocate) |
| OPENMP_DISTRIBUTE_PARALLEL_FOR_CLAUSE(order) |
| |
| // 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) |
| OPENMP_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(allocate) |
| OPENMP_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(nontemporal) |
| OPENMP_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(order) |
| |
| // 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) |
| OPENMP_DISTRIBUTE_SIMD_CLAUSE(allocate) |
| OPENMP_DISTRIBUTE_SIMD_CLAUSE(if) |
| OPENMP_DISTRIBUTE_SIMD_CLAUSE(nontemporal) |
| OPENMP_DISTRIBUTE_SIMD_CLAUSE(order) |
| |
| // 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) |
| OPENMP_TARGET_PARALLEL_FOR_SIMD_CLAUSE(allocate) |
| OPENMP_TARGET_PARALLEL_FOR_SIMD_CLAUSE(nontemporal) |
| OPENMP_TARGET_PARALLEL_FOR_SIMD_CLAUSE(order) |
| |
| // 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) |
| OPENMP_TARGET_SIMD_CLAUSE(allocate) |
| OPENMP_TARGET_SIMD_CLAUSE(nontemporal) |
| OPENMP_TARGET_SIMD_CLAUSE(order) |
| |
| // 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) |
| OPENMP_TEAMS_DISTRIBUTE_CLAUSE(allocate) |
| |
| // 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) |
| OPENMP_TEAMS_DISTRIBUTE_SIMD_CLAUSE(allocate) |
| OPENMP_TEAMS_DISTRIBUTE_SIMD_CLAUSE(if) |
| OPENMP_TEAMS_DISTRIBUTE_SIMD_CLAUSE(nontemporal) |
| OPENMP_TEAMS_DISTRIBUTE_SIMD_CLAUSE(order) |
| |
| // 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) |
| OPENMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(allocate) |
| OPENMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(nontemporal) |
| OPENMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(order) |
| |
| // 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) |
| OPENMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_CLAUSE(allocate) |
| OPENMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_CLAUSE(order) |
| |
| // 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) |
| OPENMP_TARGET_TEAMS_CLAUSE(allocate) |
| |
| // 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) |
| OPENMP_TARGET_TEAMS_DISTRIBUTE_CLAUSE(allocate) |
| |
| // 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) |
| OPENMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_CLAUSE(allocate) |
| OPENMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_CLAUSE(order) |
| |
| // 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) |
| OPENMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(allocate) |
| OPENMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(nontemporal) |
| OPENMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(order) |
| |
| // 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) |
| OPENMP_TARGET_TEAMS_DISTRIBUTE_SIMD_CLAUSE(allocate) |
| OPENMP_TARGET_TEAMS_DISTRIBUTE_SIMD_CLAUSE(nontemporal) |
| OPENMP_TARGET_TEAMS_DISTRIBUTE_SIMD_CLAUSE(order) |
| |
| // Clauses allowed for OpenMP directive 'taskgroup'. |
| OPENMP_TASKGROUP_CLAUSE(task_reduction) |
| OPENMP_TASKGROUP_CLAUSE(allocate) |
| |
| // Clauses allowed for OpenMP directive 'declare mapper'. |
| OPENMP_DECLARE_MAPPER_CLAUSE(map) |
| |
| // Device types for 'device_type' clause. |
| OPENMP_DEVICE_TYPE_KIND(host) |
| OPENMP_DEVICE_TYPE_KIND(nohost) |
| OPENMP_DEVICE_TYPE_KIND(any) |
| |
| // Clauses allowed for OpenMP directive 'declare variant'. |
| OPENMP_DECLARE_VARIANT_CLAUSE(match) |
| |
| // Type of the 'lastprivate' clause. |
| OPENMP_LASTPRIVATE_KIND(conditional) |
| |
| // Type of the 'order' clause. |
| OPENMP_ORDER_KIND(concurrent) |
| |
| // Clauses allowed for OpenMP directive 'flush'. |
| OPENMP_FLUSH_CLAUSE(acq_rel) |
| OPENMP_FLUSH_CLAUSE(acquire) |
| OPENMP_FLUSH_CLAUSE(release) |
| |
| // Clauses allowed for OpenMP directive 'depobj'. |
| OPENMP_DEPOBJ_CLAUSE(depend) |
| OPENMP_DEPOBJ_CLAUSE(destroy) |
| OPENMP_DEPOBJ_CLAUSE(update) |
| |
| // Modifiers for 'reduction' clause. |
| OPENMP_REDUCTION_MODIFIER(default) |
| OPENMP_REDUCTION_MODIFIER(inscan) |
| |
| #undef OPENMP_REDUCTION_MODIFIER |
| #undef OPENMP_SCAN_CLAUSE |
| #undef OPENMP_DEVICE_MODIFIER |
| #undef OPENMP_DEPOBJ_CLAUSE |
| #undef OPENMP_FLUSH_CLAUSE |
| #undef OPENMP_ORDER_KIND |
| #undef OPENMP_LASTPRIVATE_KIND |
| #undef OPENMP_DECLARE_VARIANT_CLAUSE |
| #undef OPENMP_DEVICE_TYPE_KIND |
| #undef OPENMP_ALLOCATE_CLAUSE |
| #undef OPENMP_DECLARE_MAPPER_CLAUSE |
| #undef OPENMP_TASKGROUP_CLAUSE |
| #undef OPENMP_PARALLEL_MASTER_TASKLOOP_SIMD_CLAUSE |
| #undef OPENMP_PARALLEL_MASTER_TASKLOOP_CLAUSE |
| #undef OPENMP_MASTER_TASKLOOP_SIMD_CLAUSE |
| #undef OPENMP_MASTER_TASKLOOP_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_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_MASTER_CLAUSE |
| #undef OPENMP_PARALLEL_SECTIONS_CLAUSE |
| #undef OPENMP_TASK_CLAUSE |
| #undef OPENMP_ATOMIC_CLAUSE |
| #undef OPENMP_TARGET_CLAUSE |
| #undef OPENMP_REQUIRES_CLAUSE |
| #undef OPENMP_ATOMIC_DEFAULT_MEM_ORDER_KIND |
| #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_MAP_MODIFIER_KIND |
| #undef OPENMP_TO_MODIFIER_KIND |
| #undef OPENMP_FROM_MODIFIER_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 |
