forked from OSchip/llvm-project
713 lines
25 KiB
C++
713 lines
25 KiB
C++
//===--- OMPKinds.def - OpenMP directives, clauses, rt-calls -*- C++ -*-===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
/// \file
|
|
///
|
|
/// This file defines the list of supported OpenMP directives, clauses, runtime
|
|
/// calls, and other things that need to be listed in enums.
|
|
///
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
/// OpenMP Directives and combined directives
|
|
///
|
|
///{
|
|
|
|
#ifndef OMP_DIRECTIVE
|
|
#define OMP_DIRECTIVE(Enum, Str)
|
|
#endif
|
|
|
|
#define __OMP_DIRECTIVE_EXT(Name, Str) OMP_DIRECTIVE(OMPD_##Name, Str)
|
|
#define __OMP_DIRECTIVE(Name) __OMP_DIRECTIVE_EXT(Name, #Name)
|
|
|
|
__OMP_DIRECTIVE(threadprivate)
|
|
__OMP_DIRECTIVE(parallel)
|
|
__OMP_DIRECTIVE(task)
|
|
__OMP_DIRECTIVE(simd)
|
|
__OMP_DIRECTIVE(for)
|
|
__OMP_DIRECTIVE(sections)
|
|
__OMP_DIRECTIVE(section)
|
|
__OMP_DIRECTIVE(single)
|
|
__OMP_DIRECTIVE(master)
|
|
__OMP_DIRECTIVE(critical)
|
|
__OMP_DIRECTIVE(taskyield)
|
|
__OMP_DIRECTIVE(barrier)
|
|
__OMP_DIRECTIVE(taskwait)
|
|
__OMP_DIRECTIVE(taskgroup)
|
|
__OMP_DIRECTIVE(flush)
|
|
__OMP_DIRECTIVE(ordered)
|
|
__OMP_DIRECTIVE(atomic)
|
|
__OMP_DIRECTIVE(target)
|
|
__OMP_DIRECTIVE(teams)
|
|
__OMP_DIRECTIVE(cancel)
|
|
__OMP_DIRECTIVE(requires)
|
|
__OMP_DIRECTIVE_EXT(target_data, "target data")
|
|
__OMP_DIRECTIVE_EXT(target_enter_data, "target enter data")
|
|
__OMP_DIRECTIVE_EXT(target_exit_data, "target exit data")
|
|
__OMP_DIRECTIVE_EXT(target_parallel, "target parallel")
|
|
__OMP_DIRECTIVE_EXT(target_parallel_for, "target parallel for")
|
|
__OMP_DIRECTIVE_EXT(target_update, "target update")
|
|
__OMP_DIRECTIVE_EXT(parallel_for, "parallel for")
|
|
__OMP_DIRECTIVE_EXT(parallel_for_simd, "parallel for simd")
|
|
__OMP_DIRECTIVE_EXT(parallel_master, "parallel master")
|
|
__OMP_DIRECTIVE_EXT(parallel_sections, "parallel sections")
|
|
__OMP_DIRECTIVE_EXT(for_simd, "for simd")
|
|
__OMP_DIRECTIVE_EXT(cancellation_point, "cancellation point")
|
|
__OMP_DIRECTIVE_EXT(declare_reduction, "declare reduction")
|
|
__OMP_DIRECTIVE_EXT(declare_mapper, "declare mapper")
|
|
__OMP_DIRECTIVE_EXT(declare_simd, "declare simd")
|
|
__OMP_DIRECTIVE(taskloop)
|
|
__OMP_DIRECTIVE_EXT(taskloop_simd, "taskloop simd")
|
|
__OMP_DIRECTIVE(distribute)
|
|
__OMP_DIRECTIVE_EXT(declare_target, "declare target")
|
|
__OMP_DIRECTIVE_EXT(end_declare_target, "end declare target")
|
|
__OMP_DIRECTIVE_EXT(distribute_parallel_for, "distribute parallel for")
|
|
__OMP_DIRECTIVE_EXT(distribute_parallel_for_simd,
|
|
"distribute parallel for simd")
|
|
__OMP_DIRECTIVE_EXT(distribute_simd, "distribute simd")
|
|
__OMP_DIRECTIVE_EXT(target_parallel_for_simd, "target parallel for simd")
|
|
__OMP_DIRECTIVE_EXT(target_simd, "target simd")
|
|
__OMP_DIRECTIVE_EXT(teams_distribute, "teams distribute")
|
|
__OMP_DIRECTIVE_EXT(teams_distribute_simd, "teams distribute simd")
|
|
__OMP_DIRECTIVE_EXT(teams_distribute_parallel_for_simd,
|
|
"teams distribute parallel for simd")
|
|
__OMP_DIRECTIVE_EXT(teams_distribute_parallel_for,
|
|
"teams distribute parallel for")
|
|
__OMP_DIRECTIVE_EXT(target_teams, "target teams")
|
|
__OMP_DIRECTIVE_EXT(target_teams_distribute, "target teams distribute")
|
|
__OMP_DIRECTIVE_EXT(target_teams_distribute_parallel_for,
|
|
"target teams distribute parallel for")
|
|
__OMP_DIRECTIVE_EXT(target_teams_distribute_parallel_for_simd,
|
|
"target teams distribute parallel for simd")
|
|
__OMP_DIRECTIVE_EXT(target_teams_distribute_simd,
|
|
"target teams distribute simd")
|
|
__OMP_DIRECTIVE(allocate)
|
|
__OMP_DIRECTIVE_EXT(declare_variant, "declare variant")
|
|
__OMP_DIRECTIVE_EXT(master_taskloop, "master taskloop")
|
|
__OMP_DIRECTIVE_EXT(parallel_master_taskloop, "parallel master taskloop")
|
|
__OMP_DIRECTIVE_EXT(master_taskloop_simd, "master taskloop simd")
|
|
__OMP_DIRECTIVE_EXT(parallel_master_taskloop_simd,
|
|
"parallel master taskloop simd")
|
|
__OMP_DIRECTIVE(depobj)
|
|
__OMP_DIRECTIVE(scan)
|
|
__OMP_DIRECTIVE_EXT(begin_declare_variant, "begin declare variant")
|
|
__OMP_DIRECTIVE_EXT(end_declare_variant, "end declare variant")
|
|
|
|
// Has to be the last because Clang implicitly expects it to be.
|
|
__OMP_DIRECTIVE(unknown)
|
|
|
|
#undef __OMP_DIRECTIVE_EXT
|
|
#undef __OMP_DIRECTIVE
|
|
#undef OMP_DIRECTIVE
|
|
|
|
///}
|
|
|
|
/// OpenMP Clauses
|
|
///
|
|
///{
|
|
|
|
#ifndef OMP_CLAUSE
|
|
#define OMP_CLAUSE(Enum, Str, Implicit)
|
|
#endif
|
|
#ifndef OMP_CLAUSE_CLASS
|
|
#define OMP_CLAUSE_CLASS(Enum, Str, Class)
|
|
#endif
|
|
#ifndef OMP_CLAUSE_NO_CLASS
|
|
#define OMP_CLAUSE_NO_CLASS(Enum, Str)
|
|
#endif
|
|
|
|
#define __OMP_CLAUSE(Name, Class) \
|
|
OMP_CLAUSE(OMPC_##Name, #Name, /* Implicit */ false) \
|
|
OMP_CLAUSE_CLASS(OMPC_##Name, #Name, Class)
|
|
#define __OMP_CLAUSE_NO_CLASS(Name) \
|
|
OMP_CLAUSE(OMPC_##Name, #Name, /* Implicit */ false) \
|
|
OMP_CLAUSE_NO_CLASS(OMPC_##Name, #Name)
|
|
#define __OMP_IMPLICIT_CLAUSE_CLASS(Name, Str, Class) \
|
|
OMP_CLAUSE(OMPC_##Name, Str, /* Implicit */ true) \
|
|
OMP_CLAUSE_CLASS(OMPC_##Name, Str, Class)
|
|
#define __OMP_IMPLICIT_CLAUSE_NO_CLASS(Name, Str) \
|
|
OMP_CLAUSE(OMPC_##Name, Str, /* Implicit */ true) \
|
|
OMP_CLAUSE_NO_CLASS(OMPC_##Name, Str)
|
|
|
|
__OMP_CLAUSE(allocator, OMPAllocatorClause)
|
|
__OMP_CLAUSE(if, OMPIfClause)
|
|
__OMP_CLAUSE(final, OMPFinalClause)
|
|
__OMP_CLAUSE(num_threads, OMPNumThreadsClause)
|
|
__OMP_CLAUSE(safelen, OMPSafelenClause)
|
|
__OMP_CLAUSE(simdlen, OMPSimdlenClause)
|
|
__OMP_CLAUSE(collapse, OMPCollapseClause)
|
|
__OMP_CLAUSE(default, OMPDefaultClause)
|
|
__OMP_CLAUSE(private, OMPPrivateClause)
|
|
__OMP_CLAUSE(firstprivate, OMPFirstprivateClause)
|
|
__OMP_CLAUSE(lastprivate, OMPLastprivateClause)
|
|
__OMP_CLAUSE(shared, OMPSharedClause)
|
|
__OMP_CLAUSE(reduction, OMPReductionClause)
|
|
__OMP_CLAUSE(linear, OMPLinearClause)
|
|
__OMP_CLAUSE(aligned, OMPAlignedClause)
|
|
__OMP_CLAUSE(copyin, OMPCopyinClause)
|
|
__OMP_CLAUSE(copyprivate, OMPCopyprivateClause)
|
|
__OMP_CLAUSE(proc_bind, OMPProcBindClause)
|
|
__OMP_CLAUSE(schedule, OMPScheduleClause)
|
|
__OMP_CLAUSE(ordered, OMPOrderedClause)
|
|
__OMP_CLAUSE(nowait, OMPNowaitClause)
|
|
__OMP_CLAUSE(untied, OMPUntiedClause)
|
|
__OMP_CLAUSE(mergeable, OMPMergeableClause)
|
|
__OMP_CLAUSE(read, OMPReadClause)
|
|
__OMP_CLAUSE(write, OMPWriteClause)
|
|
__OMP_CLAUSE(update, OMPUpdateClause)
|
|
__OMP_CLAUSE(capture, OMPCaptureClause)
|
|
__OMP_CLAUSE(seq_cst, OMPSeqCstClause)
|
|
__OMP_CLAUSE(acq_rel, OMPAcqRelClause)
|
|
__OMP_CLAUSE(acquire, OMPAcquireClause)
|
|
__OMP_CLAUSE(release, OMPReleaseClause)
|
|
__OMP_CLAUSE(relaxed, OMPRelaxedClause)
|
|
__OMP_CLAUSE(depend, OMPDependClause)
|
|
__OMP_CLAUSE(device, OMPDeviceClause)
|
|
__OMP_CLAUSE(threads, OMPThreadsClause)
|
|
__OMP_CLAUSE(simd, OMPSIMDClause)
|
|
__OMP_CLAUSE(map, OMPMapClause)
|
|
__OMP_CLAUSE(num_teams, OMPNumTeamsClause)
|
|
__OMP_CLAUSE(thread_limit, OMPThreadLimitClause)
|
|
__OMP_CLAUSE(priority, OMPPriorityClause)
|
|
__OMP_CLAUSE(grainsize, OMPGrainsizeClause)
|
|
__OMP_CLAUSE(nogroup, OMPNogroupClause)
|
|
__OMP_CLAUSE(num_tasks, OMPNumTasksClause)
|
|
__OMP_CLAUSE(hint, OMPHintClause)
|
|
__OMP_CLAUSE(dist_schedule, OMPDistScheduleClause)
|
|
__OMP_CLAUSE(defaultmap, OMPDefaultmapClause)
|
|
__OMP_CLAUSE(to, OMPToClause)
|
|
__OMP_CLAUSE(from, OMPFromClause)
|
|
__OMP_CLAUSE(use_device_ptr, OMPUseDevicePtrClause)
|
|
__OMP_CLAUSE(is_device_ptr, OMPIsDevicePtrClause)
|
|
__OMP_CLAUSE(task_reduction, OMPTaskReductionClause)
|
|
__OMP_CLAUSE(in_reduction, OMPInReductionClause)
|
|
__OMP_CLAUSE(unified_address, OMPUnifiedAddressClause)
|
|
__OMP_CLAUSE(unified_shared_memory, OMPUnifiedSharedMemoryClause)
|
|
__OMP_CLAUSE(reverse_offload, OMPReverseOffloadClause)
|
|
__OMP_CLAUSE(dynamic_allocators, OMPDynamicAllocatorsClause)
|
|
__OMP_CLAUSE(atomic_default_mem_order, OMPAtomicDefaultMemOrderClause)
|
|
__OMP_CLAUSE(allocate, OMPAllocateClause)
|
|
__OMP_CLAUSE(nontemporal, OMPNontemporalClause)
|
|
__OMP_CLAUSE(order, OMPOrderClause)
|
|
__OMP_CLAUSE(destroy, OMPDestroyClause)
|
|
__OMP_CLAUSE(detach, OMPDetachClause)
|
|
__OMP_CLAUSE(inclusive, OMPInclusiveClause)
|
|
__OMP_CLAUSE(exclusive, OMPExclusiveClause)
|
|
|
|
__OMP_CLAUSE_NO_CLASS(uniform)
|
|
__OMP_CLAUSE_NO_CLASS(device_type)
|
|
__OMP_CLAUSE_NO_CLASS(match)
|
|
|
|
__OMP_IMPLICIT_CLAUSE_CLASS(depobj, "depobj", OMPDepobjClause)
|
|
__OMP_IMPLICIT_CLAUSE_CLASS(flush, "flush", OMPFlushClause)
|
|
|
|
__OMP_IMPLICIT_CLAUSE_NO_CLASS(threadprivate, "threadprivate or thread local")
|
|
__OMP_IMPLICIT_CLAUSE_NO_CLASS(unknown, "unknown")
|
|
|
|
#undef __OMP_IMPLICIT_CLAUSE_NO_CLASS
|
|
#undef __OMP_IMPLICIT_CLAUSE_CLASS
|
|
#undef __OMP_CLAUSE
|
|
#undef OMP_CLAUSE_NO_CLASS
|
|
#undef OMP_CLAUSE_CLASS
|
|
#undef OMP_CLAUSE
|
|
|
|
///}
|
|
|
|
/// Types used in runtime structs or runtime functions
|
|
///
|
|
///{
|
|
|
|
#ifndef OMP_TYPE
|
|
#define OMP_TYPE(VarName, InitValue)
|
|
#endif
|
|
|
|
#define __OMP_TYPE(VarName) OMP_TYPE(VarName, Type::get##VarName##Ty(Ctx))
|
|
|
|
__OMP_TYPE(Void)
|
|
__OMP_TYPE(Int8)
|
|
__OMP_TYPE(Int32)
|
|
__OMP_TYPE(Int8Ptr)
|
|
__OMP_TYPE(Int32Ptr)
|
|
|
|
#undef __OMP_TYPE
|
|
#undef OMP_TYPE
|
|
|
|
///}
|
|
|
|
/// array types
|
|
///
|
|
///{
|
|
|
|
#ifndef OMP_ARRAY_TYPE
|
|
#define OMP_ARRAY_TYPE(VarName, ElemTy, ArraySize)
|
|
#endif
|
|
|
|
#define __OMP_ARRAY_TYPE(VarName, ElemTy, ArraySize) \
|
|
OMP_ARRAY_TYPE(VarName, ElemTy, ArraySize)
|
|
|
|
__OMP_ARRAY_TYPE(KmpCriticalName, Int32, 8)
|
|
|
|
#undef __OMP_ARRAY_TYPE
|
|
#undef OMP_ARRAY_TYPE
|
|
|
|
///}
|
|
|
|
/// Struct and function types
|
|
///
|
|
///{
|
|
|
|
#ifndef OMP_STRUCT_TYPE
|
|
#define OMP_STRUCT_TYPE(VarName, StructName, ...)
|
|
#endif
|
|
|
|
#define __OMP_STRUCT_TYPE(VarName, Name, ...) \
|
|
OMP_STRUCT_TYPE(VarName, "struct." #Name, __VA_ARGS__)
|
|
|
|
__OMP_STRUCT_TYPE(Ident, ident_t, Int32, Int32, Int32, Int32, Int8Ptr)
|
|
|
|
#undef __OMP_STRUCT_TYPE
|
|
#undef OMP_STRUCT_TYPE
|
|
|
|
#ifndef OMP_FUNCTION_TYPE
|
|
#define OMP_FUNCTION_TYPE(VarName, IsVarArg, ReturnType, ...)
|
|
#endif
|
|
|
|
#define __OMP_FUNCTION_TYPE(VarName, IsVarArg, ReturnType, ...) \
|
|
OMP_FUNCTION_TYPE(VarName, IsVarArg, ReturnType, __VA_ARGS__)
|
|
|
|
__OMP_FUNCTION_TYPE(ParallelTask, true, Void, Int32Ptr, Int32Ptr)
|
|
|
|
#undef __OMP_FUNCTION_TYPE
|
|
#undef OMP_FUNCTION_TYPE
|
|
|
|
///}
|
|
|
|
/// Runtime library function (and their attributes)
|
|
///
|
|
///{
|
|
|
|
#ifndef OMP_RTL
|
|
#define OMP_RTL(Enum, Str, IsVarArg, ReturnType, ...)
|
|
#endif
|
|
|
|
#define __OMP_RTL(Name, IsVarArg, ReturnType, ...) \
|
|
OMP_RTL(OMPRTL_##Name, #Name, IsVarArg, ReturnType, __VA_ARGS__)
|
|
|
|
__OMP_RTL(__kmpc_barrier, false, Void, IdentPtr, Int32)
|
|
__OMP_RTL(__kmpc_cancel, false, Int32, IdentPtr, Int32, Int32)
|
|
__OMP_RTL(__kmpc_cancel_barrier, false, Int32, IdentPtr, Int32)
|
|
__OMP_RTL(__kmpc_flush, false, Void, IdentPtr)
|
|
__OMP_RTL(__kmpc_global_thread_num, false, Int32, IdentPtr)
|
|
__OMP_RTL(__kmpc_fork_call, true, Void, IdentPtr, Int32, ParallelTaskPtr)
|
|
__OMP_RTL(__kmpc_omp_taskwait, false, Int32, IdentPtr, Int32)
|
|
__OMP_RTL(__kmpc_omp_taskyield, false, Int32, IdentPtr, Int32, Int32)
|
|
__OMP_RTL(__kmpc_push_num_threads, false, Void, IdentPtr, Int32,
|
|
/* Int */ Int32)
|
|
__OMP_RTL(__kmpc_push_proc_bind, false, Void, IdentPtr, Int32, /* Int */ Int32)
|
|
__OMP_RTL(__kmpc_serialized_parallel, false, Void, IdentPtr, Int32)
|
|
__OMP_RTL(__kmpc_end_serialized_parallel, false, Void, IdentPtr, Int32)
|
|
|
|
__OMP_RTL(omp_get_thread_num, false, Int32, )
|
|
__OMP_RTL(omp_get_num_threads, false, Int32, )
|
|
__OMP_RTL(omp_get_max_threads, false, Int32, )
|
|
__OMP_RTL(omp_in_parallel, false, Int32, )
|
|
__OMP_RTL(omp_get_dynamic, false, Int32, )
|
|
__OMP_RTL(omp_get_cancellation, false, Int32, )
|
|
__OMP_RTL(omp_get_nested, false, Int32, )
|
|
__OMP_RTL(omp_get_schedule, false, Void, Int32Ptr, Int32Ptr)
|
|
__OMP_RTL(omp_get_thread_limit, false, Int32, )
|
|
__OMP_RTL(omp_get_supported_active_levels, false, Int32, )
|
|
__OMP_RTL(omp_get_max_active_levels, false, Int32, )
|
|
__OMP_RTL(omp_get_level, false, Int32, )
|
|
__OMP_RTL(omp_get_ancestor_thread_num, false, Int32, Int32)
|
|
__OMP_RTL(omp_get_team_size, false, Int32, Int32)
|
|
__OMP_RTL(omp_get_active_level, false, Int32, )
|
|
__OMP_RTL(omp_in_final, false, Int32, )
|
|
__OMP_RTL(omp_get_proc_bind, false, Int32, )
|
|
__OMP_RTL(omp_get_num_places, false, Int32, )
|
|
__OMP_RTL(omp_get_num_procs, false, Int32, )
|
|
__OMP_RTL(omp_get_place_proc_ids, false, Void, Int32, Int32Ptr)
|
|
__OMP_RTL(omp_get_place_num, false, Int32, )
|
|
__OMP_RTL(omp_get_partition_num_places, false, Int32, )
|
|
__OMP_RTL(omp_get_partition_place_nums, false, Void, Int32Ptr)
|
|
|
|
__OMP_RTL(omp_set_num_threads, false, Void, Int32)
|
|
__OMP_RTL(omp_set_dynamic, false, Void, Int32)
|
|
__OMP_RTL(omp_set_nested, false, Void, Int32)
|
|
__OMP_RTL(omp_set_schedule, false, Void, Int32, Int32)
|
|
__OMP_RTL(omp_set_max_active_levels, false, Void, Int32)
|
|
|
|
__OMP_RTL(__kmpc_master, false, Int32, IdentPtr, Int32)
|
|
__OMP_RTL(__kmpc_end_master, false, Void, IdentPtr, Int32)
|
|
__OMP_RTL(__kmpc_critical, false, Void, IdentPtr, Int32, KmpCriticalNamePtrTy)
|
|
__OMP_RTL(__kmpc_critical_with_hint, false, Void, IdentPtr, Int32,
|
|
KmpCriticalNamePtrTy, Int32)
|
|
__OMP_RTL(__kmpc_end_critical, false, Void, IdentPtr, Int32,
|
|
KmpCriticalNamePtrTy)
|
|
|
|
__OMP_RTL(__last, false, Void, )
|
|
|
|
#undef __OMP_RTL
|
|
#undef OMP_RTL
|
|
|
|
#define EnumAttr(Kind) Attribute::get(Ctx, Attribute::AttrKind::Kind)
|
|
#define AttributeSet(...) \
|
|
AttributeSet::get(Ctx, ArrayRef<Attribute>({__VA_ARGS__}))
|
|
|
|
#ifndef OMP_ATTRS_SET
|
|
#define OMP_ATTRS_SET(VarName, AttrSet)
|
|
#endif
|
|
|
|
#define __OMP_ATTRS_SET(VarName, AttrSet) OMP_ATTRS_SET(VarName, AttrSet)
|
|
|
|
__OMP_ATTRS_SET(GetterAttrs,
|
|
OptimisticAttributes
|
|
? AttributeSet(EnumAttr(NoUnwind), EnumAttr(ReadOnly),
|
|
EnumAttr(NoSync), EnumAttr(NoFree), EnumAttr(InaccessibleMemOnly))
|
|
: AttributeSet(EnumAttr(NoUnwind)))
|
|
__OMP_ATTRS_SET(GetterArgWriteAttrs,
|
|
OptimisticAttributes
|
|
? AttributeSet(EnumAttr(NoUnwind), EnumAttr(NoSync),
|
|
EnumAttr(NoFree), EnumAttr(InaccessibleMemOrArgMemOnly))
|
|
: AttributeSet(EnumAttr(NoUnwind)))
|
|
__OMP_ATTRS_SET(SetterAttrs,
|
|
OptimisticAttributes
|
|
? AttributeSet(EnumAttr(NoUnwind), EnumAttr(WriteOnly),
|
|
EnumAttr(NoSync), EnumAttr(NoFree), EnumAttr(InaccessibleMemOnly))
|
|
: AttributeSet(EnumAttr(NoUnwind)))
|
|
|
|
#undef __OMP_ATTRS_SET
|
|
#undef OMP_ATTRS_SET
|
|
|
|
#ifndef OMP_RTL_ATTRS
|
|
#define OMP_RTL_ATTRS(Enum, FnAttrSet, RetAttrSet, ArgAttrSets)
|
|
#endif
|
|
|
|
#define __OMP_RTL_ATTRS(Name, FnAttrSet, RetAttrSet, ArgAttrSets) \
|
|
OMP_RTL_ATTRS(OMPRTL_##Name, FnAttrSet, RetAttrSet, ArgAttrSets)
|
|
|
|
__OMP_RTL_ATTRS(__kmpc_barrier,
|
|
AttributeSet(EnumAttr(InaccessibleMemOrArgMemOnly)),
|
|
AttributeSet(), {})
|
|
__OMP_RTL_ATTRS(__kmpc_cancel,
|
|
AttributeSet(EnumAttr(InaccessibleMemOrArgMemOnly)),
|
|
AttributeSet(), {})
|
|
__OMP_RTL_ATTRS(__kmpc_cancel_barrier,
|
|
AttributeSet(EnumAttr(InaccessibleMemOrArgMemOnly)),
|
|
AttributeSet(), {})
|
|
__OMP_RTL_ATTRS(__kmpc_flush,
|
|
AttributeSet(EnumAttr(InaccessibleMemOrArgMemOnly)),
|
|
AttributeSet(), {})
|
|
__OMP_RTL_ATTRS(__kmpc_global_thread_num, GetterAttrs, AttributeSet(), {})
|
|
__OMP_RTL_ATTRS(__kmpc_fork_call, AttributeSet(EnumAttr(NoUnwind)),
|
|
AttributeSet(), {})
|
|
__OMP_RTL_ATTRS(__kmpc_omp_taskwait,
|
|
AttributeSet(EnumAttr(InaccessibleMemOrArgMemOnly)),
|
|
AttributeSet(), {})
|
|
__OMP_RTL_ATTRS(__kmpc_omp_taskyield,
|
|
AttributeSet(EnumAttr(InaccessibleMemOrArgMemOnly)),
|
|
AttributeSet(), {})
|
|
__OMP_RTL_ATTRS(__kmpc_push_num_threads,
|
|
AttributeSet(EnumAttr(InaccessibleMemOrArgMemOnly)),
|
|
AttributeSet(), {})
|
|
__OMP_RTL_ATTRS(__kmpc_push_proc_bind,
|
|
AttributeSet(EnumAttr(InaccessibleMemOrArgMemOnly)),
|
|
AttributeSet(), {})
|
|
__OMP_RTL_ATTRS(__kmpc_serialized_parallel,
|
|
AttributeSet(EnumAttr(InaccessibleMemOrArgMemOnly)),
|
|
AttributeSet(), {})
|
|
__OMP_RTL_ATTRS(__kmpc_end_serialized_parallel,
|
|
AttributeSet(EnumAttr(InaccessibleMemOrArgMemOnly)),
|
|
AttributeSet(), {})
|
|
|
|
__OMP_RTL_ATTRS(omp_get_thread_num, GetterAttrs, AttributeSet(), {})
|
|
__OMP_RTL_ATTRS(omp_get_num_threads, GetterAttrs, AttributeSet(), {})
|
|
__OMP_RTL_ATTRS(omp_get_max_threads, GetterAttrs, AttributeSet(), {})
|
|
__OMP_RTL_ATTRS(omp_in_parallel, GetterAttrs, AttributeSet(), {})
|
|
__OMP_RTL_ATTRS(omp_get_dynamic, GetterAttrs, AttributeSet(), {})
|
|
__OMP_RTL_ATTRS(omp_get_cancellation, GetterAttrs, AttributeSet(), {})
|
|
__OMP_RTL_ATTRS(omp_get_nested, GetterAttrs, AttributeSet(), {})
|
|
__OMP_RTL_ATTRS(omp_get_schedule, GetterArgWriteAttrs, AttributeSet(),
|
|
ArrayRef<AttributeSet>(
|
|
{AttributeSet(EnumAttr(NoCapture), EnumAttr(WriteOnly)),
|
|
AttributeSet(EnumAttr(NoCapture), EnumAttr(WriteOnly))}))
|
|
__OMP_RTL_ATTRS(omp_get_thread_limit, GetterAttrs, AttributeSet(), {})
|
|
__OMP_RTL_ATTRS(omp_get_supported_active_levels, GetterAttrs, AttributeSet(),
|
|
{})
|
|
__OMP_RTL_ATTRS(omp_get_max_active_levels, GetterAttrs, AttributeSet(), {})
|
|
__OMP_RTL_ATTRS(omp_get_level, GetterAttrs, AttributeSet(), {})
|
|
__OMP_RTL_ATTRS(omp_get_ancestor_thread_num, GetterAttrs, AttributeSet(), {})
|
|
__OMP_RTL_ATTRS(omp_get_team_size, GetterAttrs, AttributeSet(), {})
|
|
__OMP_RTL_ATTRS(omp_get_active_level, GetterAttrs, AttributeSet(), {})
|
|
__OMP_RTL_ATTRS(omp_in_final, GetterAttrs, AttributeSet(), {})
|
|
__OMP_RTL_ATTRS(omp_get_proc_bind, GetterAttrs, AttributeSet(), {})
|
|
__OMP_RTL_ATTRS(omp_get_num_places, GetterAttrs, AttributeSet(), {})
|
|
__OMP_RTL_ATTRS(omp_get_num_procs, GetterAttrs, AttributeSet(), {})
|
|
__OMP_RTL_ATTRS(omp_get_place_proc_ids, GetterArgWriteAttrs, AttributeSet(),
|
|
ArrayRef<AttributeSet>({AttributeSet(),
|
|
AttributeSet(EnumAttr(NoCapture),
|
|
EnumAttr(WriteOnly))}))
|
|
__OMP_RTL_ATTRS(omp_get_place_num, GetterAttrs, AttributeSet(), {})
|
|
__OMP_RTL_ATTRS(omp_get_partition_num_places, GetterAttrs, AttributeSet(), {})
|
|
__OMP_RTL_ATTRS(omp_get_partition_place_nums, GetterAttrs, AttributeSet(), {})
|
|
|
|
__OMP_RTL_ATTRS(omp_set_num_threads, SetterAttrs, AttributeSet(), {})
|
|
__OMP_RTL_ATTRS(omp_set_dynamic, SetterAttrs, AttributeSet(), {})
|
|
__OMP_RTL_ATTRS(omp_set_nested, SetterAttrs, AttributeSet(), {})
|
|
__OMP_RTL_ATTRS(omp_set_schedule, SetterAttrs, AttributeSet(), {})
|
|
__OMP_RTL_ATTRS(omp_set_max_active_levels, SetterAttrs, AttributeSet(), {})
|
|
|
|
__OMP_RTL_ATTRS(__kmpc_master,
|
|
AttributeSet(EnumAttr(InaccessibleMemOrArgMemOnly)),
|
|
AttributeSet(), {})
|
|
__OMP_RTL_ATTRS(__kmpc_end_master,
|
|
AttributeSet(EnumAttr(InaccessibleMemOrArgMemOnly)),
|
|
AttributeSet(), {})
|
|
__OMP_RTL_ATTRS(__kmpc_critical,
|
|
AttributeSet(EnumAttr(InaccessibleMemOrArgMemOnly)),
|
|
AttributeSet(), {})
|
|
__OMP_RTL_ATTRS(__kmpc_critical_with_hint,
|
|
AttributeSet(EnumAttr(InaccessibleMemOrArgMemOnly)),
|
|
AttributeSet(), {})
|
|
__OMP_RTL_ATTRS(__kmpc_end_critical,
|
|
AttributeSet(EnumAttr(InaccessibleMemOrArgMemOnly)),
|
|
AttributeSet(), {})
|
|
|
|
#undef __OMP_RTL_ATTRS
|
|
#undef OMP_RTL_ATTRS
|
|
#undef AttributeSet
|
|
#undef EnumAttr
|
|
|
|
///}
|
|
|
|
/// KMP ident_t bit flags
|
|
///
|
|
/// In accordance with the values in `openmp/runtime/src/kmp.h`.
|
|
///
|
|
///{
|
|
|
|
#ifndef OMP_IDENT_FLAG
|
|
#define OMP_IDENT_FLAG(Enum, Str, Value)
|
|
#endif
|
|
|
|
#define __OMP_IDENT_FLAG(Name, Value) \
|
|
OMP_IDENT_FLAG(OMP_IDENT_FLAG_##Name, #Name, Value)
|
|
|
|
__OMP_IDENT_FLAG(KMPC, 0x02)
|
|
__OMP_IDENT_FLAG(BARRIER_EXPL, 0x20)
|
|
__OMP_IDENT_FLAG(BARRIER_IMPL, 0x0040)
|
|
__OMP_IDENT_FLAG(BARRIER_IMPL_MASK, 0x01C0)
|
|
__OMP_IDENT_FLAG(BARRIER_IMPL_FOR, 0x0040)
|
|
__OMP_IDENT_FLAG(BARRIER_IMPL_SECTIONS, 0x00C0)
|
|
__OMP_IDENT_FLAG(BARRIER_IMPL_SINGLE, 0x0140)
|
|
__OMP_IDENT_FLAG(BARRIER_IMPL_WORKSHARE, 0x01C0)
|
|
|
|
#undef __OMP_IDENT_FLAG
|
|
#undef OMP_IDENT_FLAG
|
|
|
|
///}
|
|
|
|
/// KMP cancel kind
|
|
///
|
|
///{
|
|
|
|
#ifndef OMP_CANCEL_KIND
|
|
#define OMP_CANCEL_KIND(Enum, Str, DirectiveEnum, Value)
|
|
#endif
|
|
|
|
#define __OMP_CANCEL_KIND(Name, Value) \
|
|
OMP_CANCEL_KIND(OMP_CANCEL_KIND_##Name, #Name, OMPD_##Name, Value)
|
|
|
|
__OMP_CANCEL_KIND(parallel, 1)
|
|
__OMP_CANCEL_KIND(for, 2)
|
|
__OMP_CANCEL_KIND(sections, 3)
|
|
__OMP_CANCEL_KIND(taskgroup, 4)
|
|
|
|
#undef __OMP_CANCEL_KIND
|
|
#undef OMP_CANCEL_KIND
|
|
|
|
///}
|
|
|
|
/// Default kinds
|
|
///
|
|
///{
|
|
|
|
#ifndef OMP_DEFAULT_KIND
|
|
#define OMP_DEFAULT_KIND(Enum, Str)
|
|
#endif
|
|
|
|
#define __OMP_DEFAULT_KIND(Name) OMP_DEFAULT_KIND(OMP_DEFAULT_##Name, #Name)
|
|
|
|
__OMP_DEFAULT_KIND(none)
|
|
__OMP_DEFAULT_KIND(shared)
|
|
__OMP_DEFAULT_KIND(unknown)
|
|
|
|
#undef __OMP_DEFAULT_KIND
|
|
#undef OMP_DEFAULT_KIND
|
|
|
|
///}
|
|
|
|
/// Proc bind kinds
|
|
///
|
|
///{
|
|
|
|
#ifndef OMP_PROC_BIND_KIND
|
|
#define OMP_PROC_BIND_KIND(Enum, Str, Value)
|
|
#endif
|
|
|
|
#define __OMP_PROC_BIND_KIND(Name, Value) \
|
|
OMP_PROC_BIND_KIND(OMP_PROC_BIND_##Name, #Name, Value)
|
|
|
|
__OMP_PROC_BIND_KIND(master, 2)
|
|
__OMP_PROC_BIND_KIND(close, 3)
|
|
__OMP_PROC_BIND_KIND(spread, 4)
|
|
__OMP_PROC_BIND_KIND(default, 6)
|
|
__OMP_PROC_BIND_KIND(unknown, 7)
|
|
|
|
#undef __OMP_PROC_BIND_KIND
|
|
#undef OMP_PROC_BIND_KIND
|
|
|
|
///}
|
|
|
|
/// OpenMP context related definitions:
|
|
/// - trait set selector
|
|
/// - trait selector
|
|
/// - trait property
|
|
///
|
|
///{
|
|
|
|
#ifndef OMP_TRAIT_SET
|
|
#define OMP_TRAIT_SET(Enum, Str)
|
|
#endif
|
|
#ifndef OMP_TRAIT_SELECTOR
|
|
#define OMP_TRAIT_SELECTOR(Enum, TraitSetEnum, Str, RequiresProperty)
|
|
#endif
|
|
#ifndef OMP_TRAIT_PROPERTY
|
|
#define OMP_TRAIT_PROPERTY(Enum, TraitSetEnum, TraitSelectorEnum, Str)
|
|
#endif
|
|
#ifndef OMP_LAST_TRAIT_PROPERTY
|
|
#define OMP_LAST_TRAIT_PROPERTY(Enum)
|
|
#endif
|
|
|
|
#define __OMP_TRAIT_SET(Name) OMP_TRAIT_SET(Name, #Name)
|
|
#define __OMP_TRAIT_SELECTOR(TraitSet, Name, RequiresProperty) \
|
|
OMP_TRAIT_SELECTOR(TraitSet##_##Name, TraitSet, #Name, RequiresProperty)
|
|
#define __OMP_TRAIT_SELECTOR_AND_PROPERTY(TraitSet, Name) \
|
|
OMP_TRAIT_SELECTOR(TraitSet##_##Name, TraitSet, #Name, false) \
|
|
OMP_TRAIT_PROPERTY(TraitSet##_##Name##_##Name, TraitSet, TraitSet##_##Name, \
|
|
#Name)
|
|
#define __OMP_TRAIT_PROPERTY(TraitSet, TraitSelector, Name) \
|
|
OMP_TRAIT_PROPERTY(TraitSet##_##TraitSelector##_##Name, TraitSet, \
|
|
TraitSet##_##TraitSelector, #Name)
|
|
|
|
// "invalid" must go first.
|
|
OMP_TRAIT_SET(invalid, "invalid")
|
|
OMP_TRAIT_SELECTOR(invalid, invalid, "invalid", false)
|
|
OMP_TRAIT_PROPERTY(invalid, invalid, invalid, "invalid")
|
|
|
|
__OMP_TRAIT_SET(construct)
|
|
__OMP_TRAIT_SELECTOR_AND_PROPERTY(construct, target)
|
|
__OMP_TRAIT_SELECTOR_AND_PROPERTY(construct, teams)
|
|
__OMP_TRAIT_SELECTOR_AND_PROPERTY(construct, parallel)
|
|
__OMP_TRAIT_SELECTOR_AND_PROPERTY(construct, for)
|
|
__OMP_TRAIT_SELECTOR_AND_PROPERTY(construct, simd)
|
|
|
|
__OMP_TRAIT_SET(device)
|
|
|
|
__OMP_TRAIT_SELECTOR(device, kind, true)
|
|
|
|
__OMP_TRAIT_PROPERTY(device, kind, host)
|
|
__OMP_TRAIT_PROPERTY(device, kind, nohost)
|
|
__OMP_TRAIT_PROPERTY(device, kind, cpu)
|
|
__OMP_TRAIT_PROPERTY(device, kind, gpu)
|
|
__OMP_TRAIT_PROPERTY(device, kind, fpga)
|
|
__OMP_TRAIT_PROPERTY(device, kind, any)
|
|
|
|
__OMP_TRAIT_SELECTOR(device, isa, true)
|
|
|
|
// TODO: What do we want for ISA?
|
|
|
|
__OMP_TRAIT_SELECTOR(device, arch, true)
|
|
|
|
__OMP_TRAIT_PROPERTY(device, arch, arm)
|
|
__OMP_TRAIT_PROPERTY(device, arch, armeb)
|
|
__OMP_TRAIT_PROPERTY(device, arch, aarch64)
|
|
__OMP_TRAIT_PROPERTY(device, arch, aarch64_be)
|
|
__OMP_TRAIT_PROPERTY(device, arch, aarch64_32)
|
|
__OMP_TRAIT_PROPERTY(device, arch, ppc)
|
|
__OMP_TRAIT_PROPERTY(device, arch, ppc64)
|
|
__OMP_TRAIT_PROPERTY(device, arch, ppc64le)
|
|
__OMP_TRAIT_PROPERTY(device, arch, x86)
|
|
__OMP_TRAIT_PROPERTY(device, arch, x86_64)
|
|
__OMP_TRAIT_PROPERTY(device, arch, amdgcn)
|
|
__OMP_TRAIT_PROPERTY(device, arch, nvptx)
|
|
__OMP_TRAIT_PROPERTY(device, arch, nvptx64)
|
|
|
|
__OMP_TRAIT_SET(implementation)
|
|
|
|
__OMP_TRAIT_SELECTOR(implementation, vendor, true)
|
|
|
|
__OMP_TRAIT_PROPERTY(implementation, vendor, amd)
|
|
__OMP_TRAIT_PROPERTY(implementation, vendor, arm)
|
|
__OMP_TRAIT_PROPERTY(implementation, vendor, bsc)
|
|
__OMP_TRAIT_PROPERTY(implementation, vendor, cray)
|
|
__OMP_TRAIT_PROPERTY(implementation, vendor, fujitsu)
|
|
__OMP_TRAIT_PROPERTY(implementation, vendor, gnu)
|
|
__OMP_TRAIT_PROPERTY(implementation, vendor, ibm)
|
|
__OMP_TRAIT_PROPERTY(implementation, vendor, intel)
|
|
__OMP_TRAIT_PROPERTY(implementation, vendor, llvm)
|
|
__OMP_TRAIT_PROPERTY(implementation, vendor, pgi)
|
|
__OMP_TRAIT_PROPERTY(implementation, vendor, ti)
|
|
__OMP_TRAIT_PROPERTY(implementation, vendor, unknown)
|
|
|
|
__OMP_TRAIT_SELECTOR(implementation, extension, true)
|
|
|
|
__OMP_TRAIT_SET(user)
|
|
|
|
__OMP_TRAIT_SELECTOR(user, condition, true)
|
|
|
|
__OMP_TRAIT_PROPERTY(user, condition, true)
|
|
__OMP_TRAIT_PROPERTY(user, condition, false)
|
|
__OMP_TRAIT_PROPERTY(user, condition, unknown)
|
|
|
|
#undef OMP_TRAIT_SET
|
|
#undef __OMP_TRAIT_SET
|
|
///}
|
|
|
|
/// Traits for the requires directive
|
|
///
|
|
/// These will (potentially) become trait selectors for the OpenMP context if
|
|
/// the OMP_REQUIRES_TRAIT macro is not defined.
|
|
///
|
|
///{
|
|
|
|
#ifdef OMP_REQUIRES_TRAIT
|
|
#define __OMP_REQUIRES_TRAIT(Name) \
|
|
OMP_REQUIRES_TRAIT(OMP_REQUIRES_TRAIT_##Name, #Name)
|
|
#else
|
|
#define __OMP_REQUIRES_TRAIT(Name) \
|
|
__OMP_TRAIT_SELECTOR_AND_PROPERTY(implementation, Name)
|
|
#endif
|
|
|
|
__OMP_REQUIRES_TRAIT(unified_address)
|
|
__OMP_REQUIRES_TRAIT(unified_shared_memory)
|
|
__OMP_REQUIRES_TRAIT(reverse_offload)
|
|
__OMP_REQUIRES_TRAIT(dynamic_allocators)
|
|
__OMP_REQUIRES_TRAIT(atomic_default_mem_order)
|
|
|
|
OMP_LAST_TRAIT_PROPERTY(
|
|
implementation_atomic_default_mem_order_atomic_default_mem_order)
|
|
|
|
#undef __OMP_TRAIT_SELECTOR_AND_PROPERTY
|
|
#undef OMP_TRAIT_SELECTOR
|
|
#undef __OMP_TRAIT_SELECTOR
|
|
#undef OMP_TRAIT_PROPERTY
|
|
#undef OMP_LAST_TRAIT_PROPERTY
|
|
#undef __OMP_TRAIT_PROPERTY
|
|
#undef __OMP_REQUIRES_TRAIT
|
|
#undef OMP_REQUIRES_TRAIT
|
|
///}
|