1//===- OMPConstants.h - OpenMP related constants and helpers ------ C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8/// \file
9///
10/// This file defines constans and helpers used when dealing with OpenMP.
11///
12//===----------------------------------------------------------------------===//
13
14#ifndef LLVM_FRONTEND_OPENMP_OMPCONSTANTS_H
15#define LLVM_FRONTEND_OPENMP_OMPCONSTANTS_H
16
17#include "llvm/ADT/BitmaskEnum.h"
18
19#include "llvm/ADT/StringRef.h"
20#include "llvm/Frontend/OpenMP/OMP.h.inc"
21
22namespace llvm {
23namespace omp {
24LLVM_ENABLE_BITMASK_ENUMS_IN_NAMESPACE();
25
26/// IDs for all Internal Control Variables (ICVs).
27enum class InternalControlVar {
28#define ICV_DATA_ENV(Enum, ...) Enum,
29#include "llvm/Frontend/OpenMP/OMPKinds.def"
30};
31
32#define ICV_DATA_ENV(Enum, ...) \
33 constexpr auto Enum = omp::InternalControlVar::Enum;
34#include "llvm/Frontend/OpenMP/OMPKinds.def"
35
36enum class ICVInitValue {
37#define ICV_INIT_VALUE(Enum, Name) Enum,
38#include "llvm/Frontend/OpenMP/OMPKinds.def"
39};
40
41#define ICV_INIT_VALUE(Enum, Name) \
42 constexpr auto Enum = omp::ICVInitValue::Enum;
43#include "llvm/Frontend/OpenMP/OMPKinds.def"
44
45/// IDs for all omp runtime library (RTL) functions.
46enum class RuntimeFunction {
47#define OMP_RTL(Enum, ...) Enum,
48#include "llvm/Frontend/OpenMP/OMPKinds.def"
49};
50
51#define OMP_RTL(Enum, ...) constexpr auto Enum = omp::RuntimeFunction::Enum;
52#include "llvm/Frontend/OpenMP/OMPKinds.def"
53
54/// IDs for the different default kinds.
55enum class DefaultKind {
56#define OMP_DEFAULT_KIND(Enum, Str) Enum,
57#include "llvm/Frontend/OpenMP/OMPKinds.def"
58};
59
60#define OMP_DEFAULT_KIND(Enum, ...) \
61 constexpr auto Enum = omp::DefaultKind::Enum;
62#include "llvm/Frontend/OpenMP/OMPKinds.def"
63
64/// IDs for all omp runtime library ident_t flag encodings (see
65/// their defintion in openmp/runtime/src/kmp.h).
66enum class IdentFlag {
67#define OMP_IDENT_FLAG(Enum, Str, Value) Enum = Value,
68#include "llvm/Frontend/OpenMP/OMPKinds.def"
69 LLVM_MARK_AS_BITMASK_ENUM(0x7FFFFFFF)
70};
71
72#define OMP_IDENT_FLAG(Enum, ...) constexpr auto Enum = omp::IdentFlag::Enum;
73#include "llvm/Frontend/OpenMP/OMPKinds.def"
74
75// Version of the kernel argument format used by the omp runtime.
76#define OMP_KERNEL_ARG_VERSION 2
77
78/// \note This needs to be kept in sync with kmp.h enum sched_type.
79/// Todo: Update kmp.h to include this file, and remove the enums in kmp.h
80enum class OMPScheduleType {
81 // For typed comparisons, not a valid schedule
82 None = 0,
83
84 // Schedule algorithms
85 BaseStaticChunked = 1,
86 BaseStatic = 2,
87 BaseDynamicChunked = 3,
88 BaseGuidedChunked = 4,
89 BaseRuntime = 5,
90 BaseAuto = 6,
91 BaseTrapezoidal = 7,
92 BaseGreedy = 8,
93 BaseBalanced = 9,
94 BaseGuidedIterativeChunked = 10,
95 BaseGuidedAnalyticalChunked = 11,
96 BaseSteal = 12,
97
98 // with chunk adjustment (e.g., simd)
99 BaseStaticBalancedChunked = 13,
100 BaseGuidedSimd = 14,
101 BaseRuntimeSimd = 15,
102
103 // static schedules algorithims for distribute
104 BaseDistributeChunked = 27,
105 BaseDistribute = 28,
106
107 // Modifier flags to be combined with schedule algorithms
108 ModifierUnordered = (1 << 5),
109 ModifierOrdered = (1 << 6),
110 ModifierNomerge = (1 << 7),
111 ModifierMonotonic = (1 << 29),
112 ModifierNonmonotonic = (1 << 30),
113
114 // Masks combining multiple flags
115 OrderingMask = ModifierUnordered | ModifierOrdered | ModifierNomerge,
116 MonotonicityMask = ModifierMonotonic | ModifierNonmonotonic,
117 ModifierMask = OrderingMask | MonotonicityMask,
118
119 // valid schedule type values, without monotonicity flags
120 UnorderedStaticChunked = BaseStaticChunked | ModifierUnordered, // 33
121 UnorderedStatic = BaseStatic | ModifierUnordered, // 34
122 UnorderedDynamicChunked = BaseDynamicChunked | ModifierUnordered, // 35
123 UnorderedGuidedChunked = BaseGuidedChunked | ModifierUnordered, // 36
124 UnorderedRuntime = BaseRuntime | ModifierUnordered, // 37
125 UnorderedAuto = BaseAuto | ModifierUnordered, // 38
126 UnorderedTrapezoidal = BaseTrapezoidal | ModifierUnordered, // 39
127 UnorderedGreedy = BaseGreedy | ModifierUnordered, // 40
128 UnorderedBalanced = BaseBalanced | ModifierUnordered, // 41
129 UnorderedGuidedIterativeChunked =
130 BaseGuidedIterativeChunked | ModifierUnordered, // 42
131 UnorderedGuidedAnalyticalChunked =
132 BaseGuidedAnalyticalChunked | ModifierUnordered, // 43
133 UnorderedSteal = BaseSteal | ModifierUnordered, // 44
134
135 UnorderedStaticBalancedChunked =
136 BaseStaticBalancedChunked | ModifierUnordered, // 45
137 UnorderedGuidedSimd = BaseGuidedSimd | ModifierUnordered, // 46
138 UnorderedRuntimeSimd = BaseRuntimeSimd | ModifierUnordered, // 47
139
140 OrderedStaticChunked = BaseStaticChunked | ModifierOrdered, // 65
141 OrderedStatic = BaseStatic | ModifierOrdered, // 66
142 OrderedDynamicChunked = BaseDynamicChunked | ModifierOrdered, // 67
143 OrderedGuidedChunked = BaseGuidedChunked | ModifierOrdered, // 68
144 OrderedRuntime = BaseRuntime | ModifierOrdered, // 69
145 OrderedAuto = BaseAuto | ModifierOrdered, // 70
146 OrderdTrapezoidal = BaseTrapezoidal | ModifierOrdered, // 71
147
148 OrderedDistributeChunked = BaseDistributeChunked | ModifierOrdered, // 91
149 OrderedDistribute = BaseDistribute | ModifierOrdered, // 92
150
151 NomergeUnorderedStaticChunked =
152 BaseStaticChunked | ModifierUnordered | ModifierNomerge, // 161
153 NomergeUnorderedStatic =
154 BaseStatic | ModifierUnordered | ModifierNomerge, // 162
155 NomergeUnorderedDynamicChunked =
156 BaseDynamicChunked | ModifierUnordered | ModifierNomerge, // 163
157 NomergeUnorderedGuidedChunked =
158 BaseGuidedChunked | ModifierUnordered | ModifierNomerge, // 164
159 NomergeUnorderedRuntime =
160 BaseRuntime | ModifierUnordered | ModifierNomerge, // 165
161 NomergeUnorderedAuto = BaseAuto | ModifierUnordered | ModifierNomerge, // 166
162 NomergeUnorderedTrapezoidal =
163 BaseTrapezoidal | ModifierUnordered | ModifierNomerge, // 167
164 NomergeUnorderedGreedy =
165 BaseGreedy | ModifierUnordered | ModifierNomerge, // 168
166 NomergeUnorderedBalanced =
167 BaseBalanced | ModifierUnordered | ModifierNomerge, // 169
168 NomergeUnorderedGuidedIterativeChunked =
169 BaseGuidedIterativeChunked | ModifierUnordered | ModifierNomerge, // 170
170 NomergeUnorderedGuidedAnalyticalChunked =
171 BaseGuidedAnalyticalChunked | ModifierUnordered | ModifierNomerge, // 171
172 NomergeUnorderedSteal =
173 BaseSteal | ModifierUnordered | ModifierNomerge, // 172
174
175 NomergeOrderedStaticChunked =
176 BaseStaticChunked | ModifierOrdered | ModifierNomerge, // 193
177 NomergeOrderedStatic = BaseStatic | ModifierOrdered | ModifierNomerge, // 194
178 NomergeOrderedDynamicChunked =
179 BaseDynamicChunked | ModifierOrdered | ModifierNomerge, // 195
180 NomergeOrderedGuidedChunked =
181 BaseGuidedChunked | ModifierOrdered | ModifierNomerge, // 196
182 NomergeOrderedRuntime =
183 BaseRuntime | ModifierOrdered | ModifierNomerge, // 197
184 NomergeOrderedAuto = BaseAuto | ModifierOrdered | ModifierNomerge, // 198
185 NomergeOrderedTrapezoidal =
186 BaseTrapezoidal | ModifierOrdered | ModifierNomerge, // 199
187
188 LLVM_MARK_AS_BITMASK_ENUM(/* LargestValue */ ModifierMask)
189};
190
191/// Values for bit flags used to specify the mapping type for
192/// offloading.
193enum class OpenMPOffloadMappingFlags : uint64_t {
194 /// No flags
195 OMP_MAP_NONE = 0x0,
196 /// Allocate memory on the device and move data from host to device.
197 OMP_MAP_TO = 0x01,
198 /// Allocate memory on the device and move data from device to host.
199 OMP_MAP_FROM = 0x02,
200 /// Always perform the requested mapping action on the element, even
201 /// if it was already mapped before.
202 OMP_MAP_ALWAYS = 0x04,
203 /// Delete the element from the device environment, ignoring the
204 /// current reference count associated with the element.
205 OMP_MAP_DELETE = 0x08,
206 /// The element being mapped is a pointer-pointee pair; both the
207 /// pointer and the pointee should be mapped.
208 OMP_MAP_PTR_AND_OBJ = 0x10,
209 /// This flags signals that the base address of an entry should be
210 /// passed to the target kernel as an argument.
211 OMP_MAP_TARGET_PARAM = 0x20,
212 /// Signal that the runtime library has to return the device pointer
213 /// in the current position for the data being mapped. Used when we have the
214 /// use_device_ptr or use_device_addr clause.
215 OMP_MAP_RETURN_PARAM = 0x40,
216 /// This flag signals that the reference being passed is a pointer to
217 /// private data.
218 OMP_MAP_PRIVATE = 0x80,
219 /// Pass the element to the device by value.
220 OMP_MAP_LITERAL = 0x100,
221 /// Implicit map
222 OMP_MAP_IMPLICIT = 0x200,
223 /// Close is a hint to the runtime to allocate memory close to
224 /// the target device.
225 OMP_MAP_CLOSE = 0x400,
226 /// 0x800 is reserved for compatibility with XLC.
227 /// Produce a runtime error if the data is not already allocated.
228 OMP_MAP_PRESENT = 0x1000,
229 // Increment and decrement a separate reference counter so that the data
230 // cannot be unmapped within the associated region. Thus, this flag is
231 // intended to be used on 'target' and 'target data' directives because they
232 // are inherently structured. It is not intended to be used on 'target
233 // enter data' and 'target exit data' directives because they are inherently
234 // dynamic.
235 // This is an OpenMP extension for the sake of OpenACC support.
236 OMP_MAP_OMPX_HOLD = 0x2000,
237 /// Signal that the runtime library should use args as an array of
238 /// descriptor_dim pointers and use args_size as dims. Used when we have
239 /// non-contiguous list items in target update directive
240 OMP_MAP_NON_CONTIG = 0x100000000000,
241 /// The 16 MSBs of the flags indicate whether the entry is member of some
242 /// struct/class.
243 OMP_MAP_MEMBER_OF = 0xffff000000000000,
244 LLVM_MARK_AS_BITMASK_ENUM(/* LargestFlag = */ OMP_MAP_MEMBER_OF)
245};
246
247enum OpenMPOffloadingReservedDeviceIDs {
248 /// Device ID if the device was not defined, runtime should get it
249 /// from environment variables in the spec.
250 OMP_DEVICEID_UNDEF = -1
251};
252
253enum class AddressSpace : unsigned {
254 Generic = 0,
255 Global = 1,
256 Shared = 3,
257 Constant = 4,
258 Local = 5,
259};
260
261/// \note This needs to be kept in sync with interop.h enum kmp_interop_type_t.:
262enum class OMPInteropType { Unknown, Target, TargetSync };
263
264/// Atomic compare operations. Currently OpenMP only supports ==, >, and <.
265enum class OMPAtomicCompareOp : unsigned { EQ, MIN, MAX };
266
267/// Fields ids in kmp_depend_info record.
268enum class RTLDependInfoFields { BaseAddr, Len, Flags };
269
270/// Dependence kind for RTL.
271enum class RTLDependenceKindTy {
272 DepUnknown = 0x0,
273 DepIn = 0x01,
274 DepInOut = 0x3,
275 DepMutexInOutSet = 0x4,
276 DepInOutSet = 0x8,
277 DepOmpAllMem = 0x80,
278};
279
280} // end namespace omp
281
282} // end namespace llvm
283
284#include "OMPDeviceConstants.h"
285
286#endif // LLVM_FRONTEND_OPENMP_OMPCONSTANTS_H
287

source code of include/llvm-17/llvm/Frontend/OpenMP/OMPConstants.h