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

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