//===--- 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_DEFAULT_KIND
#  define OPENMP_DEFAULT_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_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_CONTEXT_SELECTOR_SET
#define OPENMP_CONTEXT_SELECTOR_SET(Name)
#endif
#ifndef OPENMP_CONTEXT_SELECTOR
#define OPENMP_CONTEXT_SELECTOR(Name)
#endif
#ifndef OPENMP_LASTPRIVATE_KIND
#define OPENMP_LASTPRIVATE_KIND(Name)
#endif

// OpenMP context selector sets.
OPENMP_CONTEXT_SELECTOR_SET(implementation)
OPENMP_CONTEXT_SELECTOR_SET(device)

// OpenMP context selectors.
OPENMP_CONTEXT_SELECTOR(vendor)
OPENMP_CONTEXT_SELECTOR(kind)

// OpenMP clauses.
OPENMP_CLAUSE(allocator, OMPAllocatorClause)
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)
OPENMP_CLAUSE(unified_address, OMPUnifiedAddressClause)
OPENMP_CLAUSE(unified_shared_memory, OMPUnifiedSharedMemoryClause)
OPENMP_CLAUSE(reverse_offload, OMPReverseOffloadClause)
OPENMP_CLAUSE(dynamic_allocators, OMPDynamicAllocatorsClause)
OPENMP_CLAUSE(atomic_default_mem_order, OMPAtomicDefaultMemOrderClause)
OPENMP_CLAUSE(allocate, OMPAllocateClause)
OPENMP_CLAUSE(nontemporal, OMPNontemporalClause)

// 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)

// 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)

// 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)

// 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 'default' clause.
OPENMP_DEFAULT_KIND(none)
OPENMP_DEFAULT_KIND(shared)

// 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)
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(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)

// 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)

// 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)

// 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)
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)

// 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)

// 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)

// 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)

// 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)

// 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)

// 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)

// 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)

// 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)

// 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)

// 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)

// 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)

// 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)

// 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)

// 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)

// 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)

#undef OPENMP_LASTPRIVATE_KIND
#undef OPENMP_CONTEXT_SELECTOR
#undef OPENMP_CONTEXT_SELECTOR_SET
#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_DEFAULT_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
